[BACK]Return to lonparmset.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / interface

Diff for /loncom/interface/lonparmset.pm between versions 1.558 and 1.583

version 1.558, 2016/03/15 14:25:26 version 1.583, 2017/11/12 23:05:42
Line 36  lonparmset - Handler to set parameters f Line 36  lonparmset - Handler to set parameters f
   
 =head1 SYNOPSIS  =head1 SYNOPSIS
   
 lonparmset provides an interface to setting course parameters.   lonparmset provides an interface to setting content parameters in a 
   course.
   
   It contains all the code for the "Content and Problem Settings" UI, except
   for the helpers parameter.helper and resettimes.helper, and lonhelper.pm,
   and lonblockingmenu.pm.
   
 =head1 DESCRIPTION  =head1 DESCRIPTION
   
Line 133  javascript function 'pjump'. Line 138  javascript function 'pjump'.
   
 =item print_td()  =item print_td()
   
 =item print_usergroups()  =item check_other_groups()
   
 =item parm_control_group()  =item parm_control_group()
   
Line 327  use HTML::Entities; Line 332  use HTML::Entities;
 use LONCAPA qw(:DEFAULT :match);  use LONCAPA qw(:DEFAULT :match);
   
   
   ##################################################
   # CONTENT AND PROBLEM SETTINGS HTML PAGE HEADER/FOOTER
   ##################################################
   
   # Page header
   #
   # @param {Apache2::RequestRec} $r - Apache request object
   # @param {string} $mode - selected tab, 'parmset' for course and problem settings, or 'coursepref' for course settings
   # @param {string} $crstype - course type ('Community' for community settings)
 sub startSettingsScreen {  sub startSettingsScreen {
     my ($r,$mode,$crstype)=@_;      my ($r,$mode,$crstype)=@_;
   
Line 345  sub startSettingsScreen { Line 359  sub startSettingsScreen {
     $r->print('<div class="LC_Box" style="clear:both;margin:0;" id="parameditor"><div id="maincoursedoc" style="margin:0 0;padding:0 0;"><div class="LC_ContentBox" id="mainCourseDocuments" style="display: block;">');      $r->print('<div class="LC_Box" style="clear:both;margin:0;" id="parameditor"><div id="maincoursedoc" style="margin:0 0;padding:0 0;"><div class="LC_ContentBox" id="mainCourseDocuments" style="display: block;">');
 }  }
   
   # Page footer
 sub endSettingsScreen {  sub endSettingsScreen {
    my ($r)=@_;     my ($r)=@_;
    $r->print('</div></div></div>');     $r->print('</div></div></div>');
Line 352  sub endSettingsScreen { Line 367  sub endSettingsScreen {
   
   
   
   ##################################################
   # (mostly) TABLE MODE
   # (parmval is also used for the log of parameter changes)
   ##################################################
   
   # Calls parmval_by_symb, getting the symb from $id with &symbcache.
   #
   # @param {string} $what - part info and parameter name separated by a dot, e.g. '0.weight'
   # @param {string} $id - resource id or map pc
   # @param {string} $def - the resource's default value for this parameter
   # @param {string} $uname - user name
   # @param {string} $udom - user domain
   # @param {string} $csec - section name
   # @param {string} $cgroup - group name
   # @param {hash reference} $courseopt - course parameters hash (result of lonnet::get_courseresdata, dump of course's resourcedata.db)
   # @returns {Array}
 sub parmval {  sub parmval {
     my ($what,$id,$def,$uname,$udom,$csec,$cgroup,$courseopt)=@_;      my ($what,$id,$def,$uname,$udom,$csec,$cgroup,$courseopt)=@_;
     return &parmval_by_symb($what,&symbcache($id),$def,$uname,$udom,$csec,      return &parmval_by_symb($what,&symbcache($id),$def,$uname,$udom,$csec,
                                                            $cgroup,$courseopt);                                                             $cgroup,$courseopt);
 }  }
   
   # Returns an array containing
   # - the most specific level that is defined for that parameter (integer)
   # - an array with the level as index and the parameter value as value (when defined)
   #   (level 1 is the most specific and will have precedence)
   #
   # @param {string} $what - part info and parameter name separated by a dot, e.g. '0.weight'
   # @param {string} $symb - resource symb or map src
   # @param {string} $def - the resource's default value for this parameter
   # @param {string} $uname - user name
   # @param {string} $udom - user domain
   # @param {string} $csec - section name
   # @param {string} $cgroup - group name
   # @param {hash reference} $courseopt - course parameters hash (result of lonnet::get_courseresdata, dump of course's resourcedata.db)
   # @returns {Array}
 sub parmval_by_symb {  sub parmval_by_symb {
     my ($what,$symb,$def,$uname,$udom,$csec,$cgroup,$courseopt)=@_;      my ($what,$symb,$def,$uname,$udom,$csec,$cgroup,$courseopt)=@_;
   
     my $useropt;      my $useropt;
     if ($uname ne '' && $udom ne '') {      if ($uname ne '' && $udom ne '') {
     $useropt = &Apache::lonnet::get_userresdata($uname,$udom);          $useropt = &Apache::lonnet::get_userresdata($uname,$udom);
     }      }
   
     my $result='';      my $result='';
Line 371  sub parmval_by_symb { Line 416  sub parmval_by_symb {
 # ----------------------------------------------------- Cascading lookup scheme  # ----------------------------------------------------- Cascading lookup scheme
     my $map=(&Apache::lonnet::decode_symb($symb))[0];      my $map=(&Apache::lonnet::decode_symb($symb))[0];
     $map = &Apache::lonnet::deversion($map);      $map = &Apache::lonnet::deversion($map);
       
       # NOTE: some of that code looks redondant with code in lonnavmaps::parmval_real,
       # any change should be reflected there.
       
     my $symbparm=$symb.'.'.$what;      my $symbparm=$symb.'.'.$what;
     my $recurseparm=$map.'___(rec).'.$what;       my $recurseparm=$map.'___(rec).'.$what; 
     my $mapparm=$map.'___(all).'.$what;      my $mapparm=$map.'___(all).'.$what;
Line 394  sub parmval_by_symb { Line 442  sub parmval_by_symb {
   
 # --------------------------------------------------------- first, check course  # --------------------------------------------------------- first, check course
   
   # 18 - General Course
     if (defined($$courseopt{$courselevel})) {      if (defined($$courseopt{$courselevel})) {
         $outpar[18]=$$courseopt{$courselevel};          $outpar[18]=$$courseopt{$courselevel};
         $result=18;          $result=18;
     }      }
   
   # 17 - Map or Folder level in course (recursive) 
     if (defined($$courseopt{$courseleveli})) {      if (defined($$courseopt{$courseleveli})) {
         $outpar[17]=$$courseopt{$courseleveli};          $outpar[17]=$$courseopt{$courseleveli};
         $result=17;          $result=17;
     }      }
   
   # 16 - Map or Folder level in course (non-recursive)
     if (defined($$courseopt{$courselevelm})) {      if (defined($$courseopt{$courselevelm})) {
         $outpar[16]=$$courseopt{$courselevelm};          $outpar[16]=$$courseopt{$courselevelm};
         $result=16;          $result=16;
Line 411  sub parmval_by_symb { Line 462  sub parmval_by_symb {
   
 # ------------------------------------------------------- second, check default  # ------------------------------------------------------- second, check default
   
   # 15 - resource default
     if (defined($def)) { $outpar[15]=$def; $result=15; }      if (defined($def)) { $outpar[15]=$def; $result=15; }
   
 # ------------------------------------------------------ third, check map parms  # ------------------------------------------------------ third, check map parms
   
           
   # 14 - map default
     my $thisparm=&parmhash($symbparm);      my $thisparm=&parmhash($symbparm);
     if (defined($thisparm)) { $outpar[14]=$thisparm; $result=14; }      if (defined($thisparm)) { $outpar[14]=$thisparm; $result=14; }
   
   # 13 - resource level in course
     if (defined($$courseopt{$courselevelr})) {      if (defined($$courseopt{$courselevelr})) {
         $outpar[13]=$$courseopt{$courselevelr};          $outpar[13]=$$courseopt{$courselevelr};
         $result=13;          $result=13;
Line 426  sub parmval_by_symb { Line 480  sub parmval_by_symb {
   
 # ------------------------------------------------------ fourth, back to course  # ------------------------------------------------------ fourth, back to course
     if ($csec ne '') {      if ($csec ne '') {
   # 12 - General for section
         if (defined($$courseopt{$seclevel})) {          if (defined($$courseopt{$seclevel})) {
             $outpar[12]=$$courseopt{$seclevel};              $outpar[12]=$$courseopt{$seclevel};
             $result=12;              $result=12;
         }          }
   # 11 - Map or Folder level for section (recursive)
         if (defined($$courseopt{$secleveli})) {          if (defined($$courseopt{$secleveli})) {
             $outpar[11]=$$courseopt{$secleveli};              $outpar[11]=$$courseopt{$secleveli};
             $result=11;              $result=11;
         }          }
   # 10 - Map or Folder level for section (non-recursive)
         if (defined($$courseopt{$seclevelm})) {          if (defined($$courseopt{$seclevelm})) {
             $outpar[10]=$$courseopt{$seclevelm};              $outpar[10]=$$courseopt{$seclevelm};
             $result=10;              $result=10;
         }          }
   # 9 - resource level in section
         if (defined($$courseopt{$seclevelr})) {          if (defined($$courseopt{$seclevelr})) {
             $outpar[9]=$$courseopt{$seclevelr};              $outpar[9]=$$courseopt{$seclevelr};
             $result=9;              $result=9;
Line 445  sub parmval_by_symb { Line 503  sub parmval_by_symb {
     }      }
 # ------------------------------------------------------ fifth, check course group  # ------------------------------------------------------ fifth, check course group
     if ($cgroup ne '') {      if ($cgroup ne '') {
   # 8 - General for group
         if (defined($$courseopt{$grplevel})) {          if (defined($$courseopt{$grplevel})) {
             $outpar[8]=$$courseopt{$grplevel};              $outpar[8]=$$courseopt{$grplevel};
             $result=8;              $result=8;
         }          }
   # 7 - Map or Folder level for group (recursive)
         if (defined($$courseopt{$grpleveli})) {          if (defined($$courseopt{$grpleveli})) {
             $outpar[7]=$$courseopt{$grpleveli};              $outpar[7]=$$courseopt{$grpleveli};
             $result=7;              $result=7;
         }          }
   # 6 - Map or Folder level for group (non-recursive)
         if (defined($$courseopt{$grplevelm})) {          if (defined($$courseopt{$grplevelm})) {
             $outpar[6]=$$courseopt{$grplevelm};              $outpar[6]=$$courseopt{$grplevelm};
             $result=6;              $result=6;
         }          }
   # 5 - resource level in group
         if (defined($$courseopt{$grplevelr})) {          if (defined($$courseopt{$grplevelr})) {
             $outpar[5]=$$courseopt{$grplevelr};              $outpar[5]=$$courseopt{$grplevelr};
             $result=5;              $result=5;
Line 466  sub parmval_by_symb { Line 528  sub parmval_by_symb {
 # ---------------------------------------------------------- sixth, check user  # ---------------------------------------------------------- sixth, check user
   
     if ($uname ne '') {      if ($uname ne '') {
     if (defined($$useropt{$courselevel})) {  # 4 - General for specific student
         $outpar[4]=$$useropt{$courselevel};          if (defined($$useropt{$courselevel})) {
         $result=4;              $outpar[4]=$$useropt{$courselevel};
     }              $result=4;
           }
   
     if (defined($$useropt{$courseleveli})) {  # 3 - Map or Folder level for specific student (recursive)
         $outpar[3]=$$useropt{$courseleveli};          if (defined($$useropt{$courseleveli})) {
         $result=3;              $outpar[3]=$$useropt{$courseleveli};
     }              $result=3;
           }
   
     if (defined($$useropt{$courselevelm})) {  # 2 - Map or Folder level for specific student (non-recursive)
         $outpar[2]=$$useropt{$courselevelm};          if (defined($$useropt{$courselevelm})) {
         $result=2;              $outpar[2]=$$useropt{$courselevelm};
     }              $result=2;
           }
   
     if (defined($$useropt{$courselevelr})) {  # 1 - resource level for specific student
         $outpar[1]=$$useropt{$courselevelr};          if (defined($$useropt{$courselevelr})) {
         $result=1;              $outpar[1]=$$useropt{$courselevelr};
     }              $result=1;
           }
     }      }
     return ($result,@outpar);      return ($result,@outpar);
 }  }
Line 494  sub parmval_by_symb { Line 560  sub parmval_by_symb {
 # --- Caches local to lonparmset  # --- Caches local to lonparmset
   
   
   # Reset lonparmset caches (called at the beginning and end of the handler).
 sub reset_caches {  sub reset_caches {
     &resetparmhash();      &resetparmhash();
     &resetsymbcache();      &resetsymbcache();
     &resetrulescache();      &resetrulescache();
 }  }
   
   # cache for map parameters, stored temporarily in $env{'request.course.fn'}_parms.db
   # (these parameters come from param elements in .sequence files created with the advanced RAT)
 {  {
     my $parmhashid;      my $parmhashid; # course identifier, to initialize the cache only once for a course
     my %parmhash;      my %parmhash; # the parameter cache
       # reset map parameter hash
     sub resetparmhash {      sub resetparmhash {
     undef($parmhashid);          undef($parmhashid);
     undef(%parmhash);          undef(%parmhash);
     }      }
   
       # dump the _parms.db database into %parmhash
     sub cacheparmhash {      sub cacheparmhash {
     if ($parmhashid eq  $env{'request.course.fn'}) { return; }          if ($parmhashid eq  $env{'request.course.fn'}) { return; }
     my %parmhashfile;          my %parmhashfile;
     if (tie(%parmhashfile,'GDBM_File',          if (tie(%parmhashfile,'GDBM_File',
         $env{'request.course.fn'}.'_parms.db',&GDBM_READER(),0640)) {              $env{'request.course.fn'}.'_parms.db',&GDBM_READER(),0640)) {
         %parmhash=%parmhashfile;              %parmhash=%parmhashfile;
         untie(%parmhashfile);              untie(%parmhashfile);
         $parmhashid=$env{'request.course.fn'};              $parmhashid=$env{'request.course.fn'};
     }          }
     }      }
   
       # returns a parameter value for an identifier symb.parts.parameter, using the map parameter cache
     sub parmhash {      sub parmhash {
     my ($id) = @_;          my ($id) = @_;
     &cacheparmhash();          &cacheparmhash();
     return $parmhash{$id};          return $parmhash{$id};
     }      }
  }  }
   
   # cache resource id or map pc -> resource symb or map src, using lonnavmaps to find association
 {  {
     my $symbsid;      my $symbsid; # course identifier, to initialize the cache only once for a course
     my %symbs;      my %symbs; # hash id->symb
       # reset the id->symb cache
     sub resetsymbcache {      sub resetsymbcache {
     undef($symbsid);          undef($symbsid);
     undef(%symbs);          undef(%symbs);
     }      }
   
       # returns the resource symb or map src corresponding to a resource id or map pc
       # (using lonnavmaps and a cache)
     sub symbcache {      sub symbcache {
     my $id=shift;          my $id=shift;
     if ($symbsid ne $env{'request.course.id'}) {          if ($symbsid ne $env{'request.course.id'}) {
         undef(%symbs);              undef(%symbs);
     }          }
     if (!$symbs{$id}) {          if (!$symbs{$id}) {
         my $navmap = Apache::lonnavmaps::navmap->new();              my $navmap = Apache::lonnavmaps::navmap->new();
         if ($id=~/\./) {              if ($id=~/\./) {
         my $resource=$navmap->getById($id);                  my $resource=$navmap->getById($id);
         $symbs{$id}=$resource->symb();                  $symbs{$id}=$resource->symb();
         } else {              } else {
         my $resource=$navmap->getByMapPc($id);                  my $resource=$navmap->getByMapPc($id);
         $symbs{$id}=&Apache::lonnet::declutter($resource->src());                  $symbs{$id}=&Apache::lonnet::declutter($resource->src());
               }
               $symbsid=$env{'request.course.id'};
         }          }
         $symbsid=$env{'request.course.id'};          return $symbs{$id};
     }      }
     return $symbs{$id};  }
     }  
  }  
   
   # cache for parameter default actions (stored in parmdefactions.db)
 {  {
     my $rulesid;      my $rulesid; # course identifier, to initialize the cache only once for a course
     my %rules;      my %rules; # parameter default actions hash
     sub resetrulescache {      sub resetrulescache {
     undef($rulesid);          undef($rulesid);
     undef(%rules);          undef(%rules);
     }      }
   
       # returns the value for a given key in the parameter default action hash
     sub rulescache {      sub rulescache {
     my $id=shift;          my $id=shift;
     if ($rulesid ne $env{'request.course.id'}          if ($rulesid ne $env{'request.course.id'}
         && !defined($rules{$id})) {              && !defined($rules{$id})) {
         my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};              my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
         my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};              my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};
         %rules=&Apache::lonnet::dump('parmdefactions',$dom,$crs);              %rules=&Apache::lonnet::dump('parmdefactions',$dom,$crs);
         $rulesid=$env{'request.course.id'};              $rulesid=$env{'request.course.id'};
     }          }
     return $rules{$id};          return $rules{$id};
     }      }
 }  }
   
   
   # Returns the values of the parameter type default action
   # "default value when manually setting".
   # If none is defined, ('','','','','') is returned.
   #
   # @param {string} $type - parameter type
   # @returns {Array<string>} - (hours, min, sec, value)
 sub preset_defaults {  sub preset_defaults {
     my $type=shift;      my $type=shift;
     if (&rulescache($type.'_action') eq 'default') {      if (&rulescache($type.'_action') eq 'default') {
 # yes, there is something          # yes, there is something
     return (&rulescache($type.'_hours'),          return (&rulescache($type.'_hours'),
         &rulescache($type.'_min'),              &rulescache($type.'_min'),
         &rulescache($type.'_sec'),              &rulescache($type.'_sec'),
         &rulescache($type.'_value'));              &rulescache($type.'_value'));
     } else {      } else {
 # nothing there or something else          # nothing there or something else
     return ('','','','','');          return ('','','','','');
     }      }
 }  }
   
   
   # Checks that a date is after enrollment start date and before
   # enrollment end date.
   # Returns HTML with a warning if it is not, or the empty string otherwise.
   # This is used by both overview and table modes.
   #
   # @param {integer} $checkdate - the date to check.
   # @returns {string} - HTML possibly containing a localized warning message.
 sub date_sanity_info {  sub date_sanity_info {
    my $checkdate=shift;     my $checkdate=shift;
    unless ($checkdate) { return ''; }     unless ($checkdate) { return ''; }
Line 628  sub date_sanity_info { Line 716  sub date_sanity_info {
 #      }  #      }
    return $result;     return $result;
 }  }
 ##################################################  
 ##################################################  
 #  
 # Store a parameter by ID  
 #  
 # Takes  
 # - resource id  
 # - name of parameter  
 # - level  
 # - new value  
 # - new type  
 # - username  
 # - userdomain  
   
   
   # Store a parameter value and type by ID, also triggering more parameter changes based on parameter default actions.
   #
   # @param {string} $sresid - resource id or map pc
   # @param {string} $spnam - part info and parameter name separated by a dot or underscore, e.g. '0.weight'
   # @param {integer} $snum - level
   # @param {string} $nval - new value
   # @param {string} $ntype - new type
   # @param {string} $uname - username
   # @param {string} $udom - userdomain
   # @param {string} $csec - section name
   # @param {string} $cgroup - group name
 sub storeparm {  sub storeparm {
     my ($sresid,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$cgroup)=@_;      my ($sresid,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$cgroup)=@_;
     &storeparm_by_symb(&symbcache($sresid),$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,'',$cgroup);      &storeparm_by_symb(&symbcache($sresid),$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,'',$cgroup);
 }  }
   
 my %recstack;  my %recstack; # hash parameter name -> 1 when a parameter was used before in a recursive call to storeparm_by_symb
   
   # Store a parameter value and type by symb, also triggering more parameter changes based on parameter default actions.
   # Uses storeparm_by_symb_inner to actually store the parameter, ignoring any returned error.
   #
   # @param {string} $symb - resource symb or map src
   # @param {string} $spnam - part info and parameter name separated by a dot or underscore, e.g. '0.weight'
   # @param {integer} $snum - level
   # @param {string} $nval - new value
   # @param {string} $ntype - new type
   # @param {string} $uname - username
   # @param {string} $udom - userdomain
   # @param {string} $csec - section name
   # @param {boolean} $recflag - should be true for recursive calls to storeparm_by_symb, false otherwise
   # @param {string} $cgroup - group name
 sub storeparm_by_symb {  sub storeparm_by_symb {
     my ($symb,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$recflag,$cgroup)=@_;      my ($symb,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$recflag,$cgroup)=@_;
     unless ($recflag) {      unless ($recflag) {
 # first time call          # first time call
     %recstack=();          %recstack=();
     $recflag=1;          $recflag=1;
     }      }
 # store parameter      # store parameter
     &storeparm_by_symb_inner      &storeparm_by_symb_inner
     ($symb,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$cgroup);      ($symb,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$cgroup);
 # don't do anything if parameter was reset      # don't do anything if parameter was reset
     unless ($nval) { return; }      unless ($nval) { return; }
     my ($prefix,$parm)=($spnam=~/^(.*[\_\.])([^\_\.]+)$/);      my ($prefix,$parm)=($spnam=~/^(.*[\_\.])([^\_\.]+)$/);
 # remember that this was set      # remember that this was set
     $recstack{$parm}=1;      $recstack{$parm}=1;
 # what does this trigger?      # what does this trigger?
     foreach my $triggered (split(/\:/,&rulescache($parm.'_triggers'))) {      foreach my $triggered (split(/\:/,&rulescache($parm.'_triggers'))) {
 # don't backfire          # don't backfire
        unless ((!$triggered) || ($recstack{$triggered})) {          unless ((!$triggered) || ($recstack{$triggered})) {
        my $action=&rulescache($triggered.'_action');              my $action=&rulescache($triggered.'_action');
        my ($whichaction,$whichparm)=($action=~/^(.*\_)([^\_]+)$/);              my ($whichaction,$whichparm)=($action=~/^(.*\_)([^\_]+)$/);
 # set triggered parameter on same level              # set triggered parameter on same level
        my $newspnam=$prefix.$triggered;              my $newspnam=$prefix.$triggered;
        my $newvalue='';              my $newvalue='';
        my $active=1;              my $active=1;
        if ($action=~/^when\_setting/) {              if ($action=~/^when\_setting/) {
 # are there restrictions?              # are there restrictions?
            if (&rulescache($triggered.'_triggervalue')=~/\w/) {                  if (&rulescache($triggered.'_triggervalue')=~/\w/) {
            $active=0;                      $active=0;
            foreach my $possiblevalue (split(/\s*\,\s*/,&rulescache($triggered.'_triggervalue'))) {                      foreach my $possiblevalue (split(/\s*\,\s*/,&rulescache($triggered.'_triggervalue'))) {
                if (lc($possiblevalue) eq lc($nval)) { $active=1; }                          if (lc($possiblevalue) eq lc($nval)) { $active=1; }
            }                      }
            }                  }
            $newvalue=&rulescache($triggered.'_value');                  $newvalue=&rulescache($triggered.'_value');
        } else {              } else {
            my $totalsecs=((&rulescache($triggered.'_days')*24+&rulescache($triggered.'_hours'))*60+&rulescache($triggered.'_min'))*60+&rulescache($triggered.'_sec');                  my $totalsecs=((&rulescache($triggered.'_days')*24+&rulescache($triggered.'_hours'))*60+&rulescache($triggered.'_min'))*60+&rulescache($triggered.'_sec');
            if ($action=~/^later\_than/) {                  if ($action=~/^later\_than/) {
            $newvalue=$nval+$totalsecs;                      $newvalue=$nval+$totalsecs;
            } else {                  } else {
            $newvalue=$nval-$totalsecs;                      $newvalue=$nval-$totalsecs;
            }                  }
        }              }
        if ($active) {              if ($active) {
            &storeparm_by_symb($symb,$newspnam,$snum,$newvalue,&rulescache($triggered.'_type'),                  &storeparm_by_symb($symb,$newspnam,$snum,$newvalue,&rulescache($triggered.'_type'),
                    $uname,$udom,$csec,$recflag,$cgroup);                          $uname,$udom,$csec,$recflag,$cgroup);
        }              }
        }          }
     }      }
     return '';      return '';
 }  }
   
   # Adds all given arguments to the course parameter log.
   # @returns {string} - the answer to the lonnet query.
 sub log_parmset {  sub log_parmset {
     return &Apache::lonnet::write_log('course','parameterlog',@_);      return &Apache::lonnet::write_log('course','parameterlog',@_);
 }  }
   
   # Store a parameter value and type by symb, without using the parameter default actions.
   # Expire related sheets.
   #
   # @param {string} $symb - resource symb or map src
   # @param {string} $spnam - part info and parameter name separated by a dot, e.g. '0.weight'
   # @param {integer} $snum - level
   # @param {string} $nval - new value
   # @param {string} $ntype - new type
   # @param {string} $uname - username
   # @param {string} $udom - userdomain
   # @param {string} $csec - section name
   # @param {string} $cgroup - group name
   # @returns {string} - HTML code with an error message if the parameter could not be stored.
 sub storeparm_by_symb_inner {  sub storeparm_by_symb_inner {
 # ---------------------------------------------------------- Get symb, map, etc  # ---------------------------------------------------------- Get symb, map, etc
     my ($symb,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$cgroup)=@_;      my ($symb,$spnam,$snum,$nval,$ntype,$uname,$udom,$csec,$cgroup)=@_;
Line 731  sub storeparm_by_symb_inner { Line 847  sub storeparm_by_symb_inner {
     my $courselevelm=$env{'request.course.id'}.'.'.$mapparm;      my $courselevelm=$env{'request.course.id'}.'.'.$mapparm;
   
     my $storeunder='';      my $storeunder='';
       my $possreplace='';
     if (($snum==18) || ($snum==4)) { $storeunder=$courselevel; }      if (($snum==18) || ($snum==4)) { $storeunder=$courselevel; }
     if (($snum==17) || ($snum==3)) { $storeunder=$courseleveli; }       if (($snum==17) || ($snum==3)) { 
     if (($snum==16) || ($snum==2)) { $storeunder=$courselevelm; }          $storeunder=$courseleveli;
           $possreplace=$courselevelm; 
       } 
       if (($snum==16) || ($snum==2)) { 
           $storeunder=$courselevelm;
           $possreplace=$courseleveli;
       }
     if (($snum==13) || ($snum==1)) { $storeunder=$courselevelr; }      if (($snum==13) || ($snum==1)) { $storeunder=$courselevelr; }
     if ($snum==12) { $storeunder=$seclevel; }      if ($snum==12) { $storeunder=$seclevel; }
     if ($snum==11) { $storeunder=$secleveli; }      if ($snum==11) { 
     if ($snum==10) { $storeunder=$seclevelm; }          $storeunder=$secleveli;
           $possreplace=$seclevelm; 
       }
       if ($snum==10) { 
           $storeunder=$seclevelm;
           $possreplace=$secleveli;
       }
     if ($snum==9) { $storeunder=$seclevelr; }      if ($snum==9) { $storeunder=$seclevelr; }
     if ($snum==8) { $storeunder=$grplevel; }      if ($snum==8) { $storeunder=$grplevel; }
     if ($snum==7) { $storeunder=$grpleveli; }      if ($snum==7) { 
     if ($snum==6) { $storeunder=$grplevelm; }          $storeunder=$grpleveli;
           $possreplace=$grplevelm;
       }
       if ($snum==6) {
           $storeunder=$grplevelm;
           $possreplace=$grpleveli;
       }
     if ($snum==5) { $storeunder=$grplevelr; }      if ($snum==5) { $storeunder=$grplevelr; }
   
   
Line 750  sub storeparm_by_symb_inner { Line 885  sub storeparm_by_symb_inner {
     my %storecontent = ($storeunder         => $nval,      my %storecontent = ($storeunder         => $nval,
             $storeunder.'.type' => $ntype);              $storeunder.'.type' => $ntype);
     my $reply='';      my $reply='';
       
     if ($snum>4) {      if ($snum>4) {
 # ---------------------------------------------------------------- Store Course  # ---------------------------------------------------------------- Store Course
 #  #
     my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};          my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
     my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};          my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
 # Expire sheets          # Expire sheets
     &Apache::lonnet::expirespread('','','studentcalc');          &Apache::lonnet::expirespread('','','studentcalc');
     if (($snum==13) || ($snum==9) || ($snum==5)) {          if (($snum==13) || ($snum==9) || ($snum==5)) {
         &Apache::lonnet::expirespread('','','assesscalc',$symb);              &Apache::lonnet::expirespread('','','assesscalc',$symb);
     } elsif (($snum==14) || ($snum==10) || ($snum==6)) {          } elsif (($snum==17) || ($snum==16) || ($snum==11) || ($snum==10) || ($snum==7) || ($snum==6)) {
         &Apache::lonnet::expirespread('','','assesscalc',$map);              &Apache::lonnet::expirespread('','','assesscalc',$map);
     } else {          } else {
         &Apache::lonnet::expirespread('','','assesscalc');              &Apache::lonnet::expirespread('','','assesscalc');
     }          }
 # Store parameter          # Store parameter
     if ($delete) {          if ($delete) {
         $reply=&Apache::lonnet::del              $reply=&Apache::lonnet::del
         ('resourcedata',[keys(%storecontent)],$cdom,$cnum);              ('resourcedata',[keys(%storecontent)],$cdom,$cnum);
             &log_parmset(\%storecontent,1);                  &log_parmset(\%storecontent,1);
     } else {          } else {
         $reply=&Apache::lonnet::cput              $reply=&Apache::lonnet::cput
         ('resourcedata',\%storecontent,$cdom,$cnum);              ('resourcedata',\%storecontent,$cdom,$cnum);
         &log_parmset(\%storecontent);              &log_parmset(\%storecontent);
     }              if ($possreplace) {
     &Apache::lonnet::devalidatecourseresdata($cnum,$cdom);                  my $resdata = &Apache::lonnet::get_courseresdata($cnum,$cdom);
                   if (ref($resdata) eq 'HASH') {
                       if (exists($resdata->{$possreplace})) {
                           if (&Apache::lonnet::del
                               ('resourcedata',[$possreplace,$possreplace.'.type'],$cdom,$cnum) eq 'ok') {
                               &log_parmset({$possreplace => '', $possreplace.'.type' => $ntype},1);   
                           }
                       }
                   }
               }
           }
           &Apache::lonnet::devalidatecourseresdata($cnum,$cdom);
     } else {      } else {
 # ------------------------------------------------------------------ Store User  # ------------------------------------------------------------------ Store User
 #  #
 # Expire sheets          # Expire sheets
     &Apache::lonnet::expirespread($uname,$udom,'studentcalc');          &Apache::lonnet::expirespread($uname,$udom,'studentcalc');
     if ($snum==1) {          if ($snum==1) {
         &Apache::lonnet::expirespread              &Apache::lonnet::expirespread
         ($uname,$udom,'assesscalc',$symb);              ($uname,$udom,'assesscalc',$symb);
     } elsif ($snum==2) {          } elsif (($snum==2) || ($snum==3)) {
         &Apache::lonnet::expirespread              &Apache::lonnet::expirespread
         ($uname,$udom,'assesscalc',$map);              ($uname,$udom,'assesscalc',$map);
     } else {          } else {
         &Apache::lonnet::expirespread($uname,$udom,'assesscalc');              &Apache::lonnet::expirespread($uname,$udom,'assesscalc');
     }          }
 # Store parameter          # Store parameter
     if ($delete) {          if ($delete) {
         $reply=&Apache::lonnet::del              $reply=&Apache::lonnet::del
         ('resourcedata',[keys(%storecontent)],$udom,$uname);              ('resourcedata',[keys(%storecontent)],$udom,$uname);
         &log_parmset(\%storecontent,1,$uname,$udom);              &log_parmset(\%storecontent,1,$uname,$udom);
     } else {          } else {
         $reply=&Apache::lonnet::cput              $reply=&Apache::lonnet::cput
         ('resourcedata',\%storecontent,$udom,$uname);              ('resourcedata',\%storecontent,$udom,$uname);
         &log_parmset(\%storecontent,0,$uname,$udom);              &log_parmset(\%storecontent,0,$uname,$udom);
     }              if ($possreplace) {
     &Apache::lonnet::devalidateuserresdata($uname,$udom);                  my $resdata = &Apache::lonnet::get_userresdata($uname,$udom);
                   if (ref($resdata) eq 'HASH') {
                       if (exists($resdata->{$possreplace})) {
                           if (&Apache::lonnet::del
                               ('resourcedata',[$possreplace,$possreplace.'.type'],$udom,$uname) eq 'ok') {
                               &log_parmset({$possreplace => '',$possreplace.'.type' => $ntype},1,
                                             $uname,$udom);
                           }
                       }
                   }
               }
           }
           &Apache::lonnet::devalidateuserresdata($uname,$udom);
     }      }
   
     if ($reply=~/^error\:(.*)/) {      if ($reply=~/^error\:(.*)/) {
     return "<span class=\"LC_error\">Write Error: $1</span>";          return "<span class=\"LC_error\">Write Error: $1</span>";
     }      }
     return '';      return '';
 }  }
   
   
   # Returns HTML with the value of the given parameter,
   # using a readable format for dates, and
   # a warning if there is a problem with a date.
   # Used by table mode.
   # Returns HTML for the editmap.png image if no value is defined and $editable is true.
   #
   # @param {string} $value - the parameter value
   # @param {string} $type - the parameter type
   # @param {string} $name - the parameter name (unused)
   # @param {boolean} $editable - Set to true to get an icon when no value is defined.
 sub valout {  sub valout {
     my ($value,$type,$name,$editable)=@_;      my ($value,$type,$name,$editable)=@_;
     my $result = '';      my $result = '';
Line 824  sub valout { Line 993  sub valout {
         }          }
     } else {      } else {
         if ($type eq 'date_interval') {          if ($type eq 'date_interval') {
             my ($totalsecs,$donebutton,$proctor,$secretkey) = split(/_/,$value);              my ($totalsecs,$donesuffix) = split(/_/,$value,2);
               my ($usesdone,$donebuttontext,$proctor,$secretkey);
               if ($donesuffix =~ /^done\:([^\:]+)\:(.*)$/) {
                   $donebuttontext = $1;
                   (undef,$proctor,$secretkey) = split(/_/,$2);
                   $usesdone = 'done';
               } elsif ($donesuffix =~ /^done(|_.+)$/) {
                   $donebuttontext = &mt('Done');
                   ($usesdone,$proctor,$secretkey) = split(/_/,$donesuffix);
               }
             my ($sec,$min,$hour,$mday,$mon,$year)=gmtime($totalsecs);              my ($sec,$min,$hour,$mday,$mon,$year)=gmtime($totalsecs);
             my @timer;              my @timer;
             $year=$year-70;              $year=$year-70;
Line 858  sub valout { Line 1036  sub valout {
                 push(@timer,&mt('[quant,_1,sec]',0));                  push(@timer,&mt('[quant,_1,sec]',0));
             }              }
             $result.=join(", ",@timer);              $result.=join(", ",@timer);
             if ($donebutton eq 'done') {              if ($usesdone eq 'done') {
                 if ($secretkey) {                  if ($secretkey) {
                     $result .= ' '.&mt('+ "done" with proctor key: [_1]',$secretkey);                        $result .= ' '.&mt('+ "[_1]" with proctor key: [_2]',$donebuttontext,$secretkey);  
                 } else {                  } else {
                     $result .= ' '.&mt('+ "done"');                      $result .= ' + "'.$donebuttontext.'"';
                 }                    }
             }              }
         } elsif (&isdateparm($type)) {          } elsif (&isdateparm($type)) {
             $result = &Apache::lonlocal::locallocaltime($value).              $result = &Apache::lonlocal::locallocaltime($value).
         &date_sanity_info($value);                  &date_sanity_info($value);
         } else {          } else {
             $result = $value;              $result = $value;
             $result=~s/\,/\, /gs;              $result=~s/\,/\, /gs;
         $result = &HTML::Entities::encode($result,'"<>&');              $result = &HTML::Entities::encode($result,'"<>&');
         }          }
     }      }
     return $result;      return $result;
 }  }
   
   
   # Returns HTML containing a link on a parameter value, for table mode.
   # The link uses the javascript function 'pjump'.
   #
   # @param {string} $type - parameter type
   # @param {string} $dis - dialog title for editing the parameter value and type
   # @param {string} $value - parameter value
   # @param {string} $marker - identifier for the parameter, "resource id&part_parameter name&level", will be passed as pres_marker when the user submits a change.
   # @param {string} $return - prefix for the name of the form and field names that will be used to submit the form ('parmform.pres')
   # @param {string} $call - javascript function to call to submit the form ('psub')
   # @param {boolean} $recursive - true if link is for a map/folder where parameter is currently set to be recursive. 
 sub plink {  sub plink {
     my ($type,$dis,$value,$marker,$return,$call)=@_;      my ($type,$dis,$value,$marker,$return,$call,$recursive)=@_;
     my $winvalue=$value;      my $winvalue=$value;
     unless ($winvalue) {      unless ($winvalue) {
     if (&isdateparm($type)) {          if (&isdateparm($type)) {
             $winvalue=$env{'form.recent_'.$type};              $winvalue=$env{'form.recent_'.$type};
         } else {          } else {
             $winvalue=$env{'form.recent_'.(split(/\_/,$type))[0]};              $winvalue=$env{'form.recent_'.(split(/\_/,$type))[0]};
Line 895  sub plink { Line 1083  sub plink {
     my $unencmarker = $marker;      my $unencmarker = $marker;
     foreach my $item (\$type, \$dis, \$winvalue, \$marker, \$return, \$call,      foreach my $item (\$type, \$dis, \$winvalue, \$marker, \$return, \$call,
               \$hour, \$min, \$sec) {                \$hour, \$min, \$sec) {
     $$item = &HTML::Entities::encode($$item,'"<>&');          $$item = &HTML::Entities::encode($$item,'"<>&');
     $$item =~ s/\'/\\\'/g;          $$item =~ s/\'/\\\'/g;
     }      }
     return '<table width="100%"><tr valign="top" align="right"><td><a name="'.$unencmarker.'" /></td></tr><tr><td align="center">'.      return '<table width="100%"><tr valign="top" align="right"><td><a name="'.$unencmarker.'" /></td></tr><tr><td align="center">'.
     '<a href="javascript:pjump('."'".$type."','".$dis."','".$winvalue."','"      '<a href="javascript:pjump('."'".$type."','".$dis."','".$winvalue."','"
         .$marker."','".$return."','".$call."','".$hour."','".$min."','".$sec."'".');">'.          .$marker."','".$return."','".$call."','".$hour."','".$min."','".$sec."'".');">'.
         $valout.'</a></td></tr></table>';          $valout.'</a></td></tr>'.($recursive?'<tr><td align="center" class="LC_parm_recursive">'.
                                                 &mt('recursive').'</td></tr>' : '').'</table>';
   
 }  }
   
   # Javascript for table mode.
 sub page_js {  sub page_js {
   
     my $selscript=&Apache::loncommon::studentbrowser_javascript();      my $selscript=&Apache::loncommon::studentbrowser_javascript();
Line 920  sub page_js { Line 1111  sub page_js {
             document.parmform.action+='#'+document.parmform.pres_marker.value;              document.parmform.action+='#'+document.parmform.pres_marker.value;
             var typedef=new Array();              var typedef=new Array();
             typedef=document.parmform.pres_type.value.split('_');              typedef=document.parmform.pres_type.value.split('_');
            if (document.parmform.pres_type.value!='') {              if (document.parmform.pres_type.value!='') {
             if (typedef[0]=='date') {                  if (typedef[0]=='date') {
                 eval('document.parmform.recent_'+                      eval('document.parmform.recent_'+
                      document.parmform.pres_type.value+                          document.parmform.pres_type.value+
              '.value=document.parmform.pres_value.value;');                          '.value=document.parmform.pres_value.value;');
             } else {                  } else {
                 eval('document.parmform.recent_'+typedef[0]+                      eval('document.parmform.recent_'+typedef[0]+
              '.value=document.parmform.pres_value.value;');                          '.value=document.parmform.pres_value.value;');
                   }
             }              }
        }  
             document.parmform.submit();              document.parmform.submit();
         } else {          } else {
             document.parmform.pres_value.value='';              document.parmform.pres_value.value='';
Line 953  ENDJS Line 1144  ENDJS
   
 }  }
   
   # Javascript to show or hide the map selection (function showHide_courseContent),
   # for table and overview modes.
 sub showhide_js {  sub showhide_js {
     return <<"COURSECONTENTSCRIPT";      return <<"COURSECONTENTSCRIPT";
   
Line 973  function showHide_courseContent() { Line 1166  function showHide_courseContent() {
 COURSECONTENTSCRIPT  COURSECONTENTSCRIPT
 }  }
   
   # Javascript functions showHideLenient and toggleParmTextbox, for overview mode
 sub toggleparmtextbox_js {  sub toggleparmtextbox_js {
     return <<"ENDSCRIPT";      return <<"ENDSCRIPT";
   
Line 1032  function toggleParmTextbox(form,key) { Line 1226  function toggleParmTextbox(form,key) {
 ENDSCRIPT  ENDSCRIPT
 }  }
   
   # Javascript function validateParms, for overview mode
 sub validateparms_js {  sub validateparms_js {
     return <<'ENDSCRIPT';      return <<'ENDSCRIPT';
   
Line 1105  function validateParms() { Line 1300  function validateParms() {
 ENDSCRIPT  ENDSCRIPT
 }  }
   
   # Javascript initialization, for overview mode
 sub ipacc_boxes_js  {  sub ipacc_boxes_js  {
     my $remove = &mt('Remove');      my $remove = &mt('Remove');
     return <<"END";      return <<"END";
Line 1129  sub ipacc_boxes_js  { Line 1325  sub ipacc_boxes_js  {
 END  END
 }  }
   
   # Javascript function toggleSecret, for overview mode.
 sub done_proctor_js {  sub done_proctor_js {
     return <<"END";      return <<"END";
 function toggleSecret(form,radio,key) {  function toggleSecret(form,radio,key) {
Line 1154  END Line 1351  END
   
 }  }
   
   # Prints HTML page start for table mode.
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {string} $psymb - resource symb
   # @param {string} $crstype - course type (Community / Course / Placement Test)
 sub startpage {  sub startpage {
     my ($r,$psymb,$crstype) = @_;      my ($r,$psymb,$crstype) = @_;
   
Line 1164  sub startpage { Line 1365  sub startpage {
         $loaditems{'onload'} = "showHide_courseContent(); group_or_section('cgroup'); resize_scrollbox('mapmenuscroll','1','1');";          $loaditems{'onload'} = "showHide_courseContent(); group_or_section('cgroup'); resize_scrollbox('mapmenuscroll','1','1');";
     }      }
   
     if ((($env{'form.command'} eq 'set') && ($env{'form.url'})      if ((($env{'form.command'} eq 'set') && ($env{'form.url'}) &&
          && (!$env{'form.dis'})) || ($env{'form.symb'})) {              (!$env{'form.dis'})) || ($env{'form.symb'})) {
     &Apache::lonhtmlcommon::add_breadcrumb({help=>'Problem_Parameters',          &Apache::lonhtmlcommon::add_breadcrumb({help=>'Problem_Parameters',
         text=>"Problem Parameters"});              text=>"Problem Parameters"});
     } else {      } else {
     &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=settable',          &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=settable',
        text=>"Table Mode",              text=>"Table Mode",
        help => 'Course_Setting_Parameters'});              help => 'Course_Setting_Parameters'});
     }      }
     my $js = &page_js().'      my $js = &page_js().'
 <script type="text/javascript">  <script type="text/javascript">
Line 1202  ENDHEAD Line 1403  ENDHEAD
 }  }
   
   
   # Prints a row for table mode (except for the tr start).
   # Every time a hash reference is passed, a single entry is used, so print_row
   # could just use these values, but why make it simple when it can be complicated ?
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {string} $which - parameter key ('parameter_'.part.'_'.name)
   # @param {hash reference} $part - parameter key -> parameter part (can be problem part.'_'.response id for response parameters)
   # @param {hash reference} $name - parameter key -> parameter name
   # @param {hash reference} $symbp - map pc or resource/map id -> map src.'___(all)' or resource symb
   # @param {string} $rid - resource id
   # @param {hash reference} $default - parameter key -> resource parameter default value
   # @param {hash reference} $defaulttype - parameter key -> resource parameter default type
   # @param {hash reference} $display - parameter key -> full title for the parameter
   # @param {string} $defbgone - user level and other levels background color
   # @param {string} $defbgtwo - section level background color, also used for part number
   # @param {string} $defbgthree - group level background color
   # @param {string} $parmlev - parameter level (Resource:'full', Map:'map', Course:'general')
   # @param {string} $uname - user name
   # @param {string} $udom - user domain
   # @param {string} $csec - section name
   # @param {string} $cgroup - group name
   # @param {array reference} $usersgroups - list of groups the user belongs to, if any
   # @param {boolean} $noeditgrp - true if no edit is allowed for group level parameters
   # @param {boolean} $readonly - true if no editing allowed.
   # @param {array reference} - $recurseup - list of maps containing current one, ending at top-level.
   # @param {hash reference} - $maptitles - - hash map id or src -> map title 
   # @param {hash reference} - $allmaps_inverted - hash map src -> map pc
   # @param {scalar reference} - $reclinks - number of "parameter in effect" cells with link to map where recursive param was set 
 sub print_row {  sub print_row {
     my ($r,$which,$part,$name,$symbp,$rid,$default,$defaulttype,$display,$defbgone,      my ($r,$which,$part,$name,$symbp,$rid,$default,$defaulttype,$display,$defbgone,
     $defbgtwo,$defbgthree,$parmlev,$uname,$udom,$csec,$cgroup,$usersgroups,$noeditgrp)=@_;      $defbgtwo,$defbgthree,$parmlev,$uname,$udom,$csec,$cgroup,$usersgroups,$noeditgrp,
       $readonly,$recurseup,$maptitles,$allmaps_inverted,$reclinks)=@_;
     my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};      my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
     my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
     my $courseopt=&Apache::lonnet::get_courseresdata($cnum,$cdom);      my $courseopt=&Apache::lonnet::get_courseresdata($cnum,$cdom);
       my $numlinks = 0;
   
 # get the values for the parameter in cascading order      # get the values for the parameter in cascading order
 # empty levels will remain empty      # empty levels will remain empty
     my ($result,@outpar)=&parmval($$part{$which}.'.'.$$name{$which},      my ($result,@outpar)=&parmval($$part{$which}.'.'.$$name{$which},
       $rid,$$default{$which},$uname,$udom,$csec,$cgroup,$courseopt);        $rid,$$default{$which},$uname,$udom,$csec,$cgroup,$courseopt);
 # get the type for the parameters      # get the type for the parameters
 # problem: these may not be set for all levels      # problem: these may not be set for all levels
     my ($typeresult,@typeoutpar)=&parmval($$part{$which}.'.'.      my ($typeresult,@typeoutpar)=&parmval($$part{$which}.'.'.
                                           $$name{$which}.'.type',$rid,                                            $$name{$which}.'.type',$rid,
          $$defaulttype{$which},$uname,$udom,$csec,$cgroup,$courseopt);           $$defaulttype{$which},$uname,$udom,$csec,$cgroup,$courseopt);
 # cascade down manually      # cascade down manually
     my $cascadetype=$$defaulttype{$which};      my $cascadetype=$$defaulttype{$which};
     for (my $i=18;$i>0;$i--) {      for (my $i=18;$i>0;$i--) {
      if ($typeoutpar[$i]) {          if ($typeoutpar[$i]) {
             $cascadetype=$typeoutpar[$i];              $cascadetype=$typeoutpar[$i];
     } else {          } else {
             $typeoutpar[$i]=$cascadetype;              $typeoutpar[$i]=$cascadetype;
         }          }
     }      }
Line 1237  sub print_row { Line 1468  sub print_row {
     }      }
     my $automatic=&rulescache(($which=~/\_([^\_]+)$/)[0].'_triggers');      my $automatic=&rulescache(($which=~/\_([^\_]+)$/)[0].'_triggers');
     if ($automatic) {      if ($automatic) {
     $parm.='<span class="LC_warning"><br />'.&mt('Automatically sets').' '.join(', ',split(/\:/,$automatic)).'</span>';          $parm.='<span class="LC_warning"><br />'.&mt('Automatically sets').' '.join(', ',split(/\:/,$automatic)).'</span>';
     }      }
     $r->print('<td>'.$parm.'</td>');      $r->print('<td>'.$parm.'</td>');
   
     my $thismarker=$which;      my $thismarker=$which;
     $thismarker=~s/^parameter\_//;      $thismarker=~s/^parameter\_//;
     my $mprefix=$rid.'&'.$thismarker.'&';      my $mprefix=$rid.'&'.$thismarker.'&';
     my $effective_parm = &valout($outpar[$result],$typeoutpar[$result],$thismarker);      my ($parmname)=($thismarker=~/\_([^\_]+)$/);
     my ($othergrp,$grp_parm,$controlgrp);      my ($othergrp,$grp_parm,$controlgrp,$effective_parm,$effparm_rec,$effparm_level,
           $eff_groupparm,$recurse_check,$recursinfo);
       if ((ref($recurseup) eq 'ARRAY') && (@{$recurseup} > 0)) {
           if ($result eq '') {
               $recurse_check = 1;
           } elsif (($uname ne '') && ($result > 3)) {
               $recurse_check = 1;
           } elsif (($cgroup ne '') && ($result > 7)) {
               $recurse_check = 1;
           } elsif (($csec ne '') && ($result > 11)) {
               $recurse_check = 1;
           } elsif ($result > 17) {
               $recurse_check = 1;
           }
           if ($recurse_check) {
               my $what = $$part{$which}.'.'.$$name{$which};
               my $prefix;
               if (($uname ne '') && ($udom ne '')) {
                   my $useropt = &Apache::lonnet::get_userresdata($uname,$udom);
                   $prefix = $env{'request.course.id'};
                   $recursinfo = &get_recursive($recurseup,$useropt,$what,$prefix);
                   if (ref($recursinfo) eq 'ARRAY') {
                       $effparm_rec = 1;
                       $effparm_level = &mt('user: [_1]',$uname);
                   }
               }
               if (($cgroup ne '') && (!$effparm_rec)) {
                   $prefix = $env{'request.course.id'}.'.['.$cgroup.']';
                   $recursinfo = &get_recursive($recurseup,$courseopt,$what,$prefix);
                   if (ref($recursinfo) eq 'ARRAY') {
                       $effparm_rec = 1;
                       $effparm_level = &mt('group: [_1]',$cgroup);
                   }
               }
               if (($csec ne '') && (!$effparm_rec)) {
                   $prefix = $env{'request.course.id'}.'.['.$csec.']';
                   $recursinfo = &get_recursive($recurseup,$courseopt,$what,$prefix);
                   if (ref($recursinfo) eq 'ARRAY') {
                       $effparm_rec = 1;
                       $effparm_level = &mt('section: [_1]',$csec);
                   }
               }
               if (!$effparm_rec) {
                   $prefix = $env{'request.course.id'};
                   $recursinfo = &get_recursive($recurseup,$courseopt,$what,$prefix); 
                   if (ref($recursinfo) eq 'ARRAY') {
                       $effparm_rec = 1;
                   }
               }
           }
       }
       if ((!$effparm_rec) && ($result == 17 || $result == 11 || $result == 7 || $result == 3)) {
           $effparm_rec = 1;
       }
       if ((!$effparm_rec) && 
           (($$name{$which} eq 'encrypturl') || ($$name{$which} eq 'hiddenresource')) && 
           ($result == 16 || $result == 10 || $result == 6 || $result == 2)) {
           $effparm_rec = 1;
       }
     if ($parmlev eq 'general') {      if ($parmlev eq 'general') {
         if ($uname) {          if ($uname) {
             &print_td($r,4,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,4,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         } elsif ($cgroup) {          } elsif ($cgroup) {
             &print_td($r,8,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);              &print_td($r,8,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp,$readonly);
         } elsif ($csec) {          } elsif ($csec) {
             &print_td($r,12,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,12,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         } else {          } else {
             &print_td($r,18,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,18,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         }          }
     } elsif ($parmlev eq 'map') {      } elsif ($parmlev eq 'map') {
         if ($uname) {          if ($uname) {
             &print_td($r,3,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,2,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly,1); 
             &print_td($r,2,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);   
         } elsif ($cgroup) {          } elsif ($cgroup) {
             &print_td($r,7,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);              &print_td($r,6,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp,$readonly,1);
             &print_td($r,6,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);  
         } elsif ($csec) {          } elsif ($csec) {
             &print_td($r,11,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,10,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly,1);
             &print_td($r,10,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);  
         } else {          } else {
             &print_td($r,17,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,16,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly,1);
             &print_td($r,16,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);  
         }          }
     } else {      } else {
         if ($uname) {          if ($uname) {
             if (@{$usersgroups} > 1) {              if (@{$usersgroups} > 1) {
                 my ($coursereply,$grp_parm,$controlgrp);                  (my $coursereply,$othergrp,$grp_parm,$controlgrp,my $grp_is_rec) =
                 ($coursereply,$othergrp,$grp_parm,$controlgrp) =                      &check_other_groups($$part{$which}.'.'.$$name{$which},
                     &print_usergroups($r,$$part{$which}.'.'.$$name{$which},  
                        $rid,$cgroup,$defbgone,$usersgroups,$result,$courseopt);                         $rid,$cgroup,$defbgone,$usersgroups,$result,$courseopt);
                 if ($coursereply && $result > 4) {                  if (($coursereply) && ($result > 4)) {
                     if (defined($controlgrp)) {                      if (defined($controlgrp)) {
                         if ($cgroup ne $controlgrp) {                          if ($cgroup ne $controlgrp) {
                             $effective_parm = $grp_parm;                              $eff_groupparm = $grp_parm;
                             $result = 0;                              undef($result);
                               undef($effparm_rec);
                               if ($grp_is_rec) {
                                    $effparm_rec = 1;
                               }
                         }                          }
                     }                      }
                 }                  }
             }              }
         }          }
   
         &print_td($r,18,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);          &print_td($r,18,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         &print_td($r,17,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);          &print_td($r,16,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly,1);
         &print_td($r,16,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);          &print_td($r,15,'#FFDDDD',$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         &print_td($r,15,'#FFDDDD',$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);          &print_td($r,14,'#FFDDDD',$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         &print_td($r,14,'#FFDDDD',$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);          &print_td($r,13,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
         &print_td($r,13,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);  
   
         if ($csec) {          if ($csec) {
             &print_td($r,12,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,12,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
             &print_td($r,11,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,10,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly,1);
             &print_td($r,10,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,9,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
             &print_td($r,9,$defbgtwo,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);  
         }          }
   
         if ($cgroup) {          if ($cgroup) {
             &print_td($r,8,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);              &print_td($r,8,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp,$readonly);
             &print_td($r,7,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);              &print_td($r,6,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp,$readonly,1);
             &print_td($r,6,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);              &print_td($r,5,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp.$readonly);
             &print_td($r,5,$defbgthree,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,$noeditgrp);  
         }          }
   
         if ($uname) {          if ($uname) {
             if ($othergrp) {              if ($othergrp) {
                 $r->print($othergrp);                  $r->print($othergrp);
             }              }
             &print_td($r,4,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,4,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
             &print_td($r,3,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,2,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly,1);
             &print_td($r,2,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);              &print_td($r,1,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display,'',$readonly);
             &print_td($r,1,$defbgone,$result,\@outpar,$mprefix,$which,\@typeoutpar,$display);  
         }          }
   
     } # end of $parmlev if/else      } # end of $parmlev if/else
     $r->print('<td style="background-color:#CCCCFF;" align="center">'.$effective_parm.'</td>');      if (ref($recursinfo) eq 'ARRAY') {
           my $rectitle = &mt('recursive');
           if ((ref($maptitles) eq 'HASH') && (exists($maptitles->{$recursinfo->[2]}))) {
               if ((ref($allmaps_inverted) eq 'HASH') && (exists($allmaps_inverted->{$recursinfo->[2]}))) {
                   $rectitle = &mt('set in: [_1]','"'.
                                   '<a href="javascript:pjumprec('."'".$allmaps_inverted->{$recursinfo->[2]}."',".
                                                                 "'$parmname','$$part{$which}'".');">'.
                                   $maptitles->{$recursinfo->[2]}.'</a>"');
                 
                   $numlinks ++;
               }
           }
           my ($parmname)=($thismarker=~/\_([^\_]+)$/);
           $effective_parm = &valout($recursinfo->[0],$recursinfo->[1],$parmname);
           $r->print('<td style="background-color:#CCCCFF;" align="center">'.$effective_parm.
                     '<br /><span class="LC_parm_recursive">'.$rectitle.'&nbsp;'.
                     $effparm_level.'</span></td>');
       } else {
           if ($result) {
               $effective_parm = &valout($outpar[$result],$typeoutpar[$result],$parmname);
           }
           if ($eff_groupparm) {
               $effective_parm = $eff_groupparm;
           }
           $r->print('<td style="background-color:#CCCCFF;" align="center">'.$effective_parm.
                     ($effparm_rec?'<br /><span class="LC_parm_recursive">'.&mt('recursive').
                                   '</span>':'').'</td>');
       }
     if ($parmlev eq 'full') {      if ($parmlev eq 'full') {
         my $sessionval=&Apache::lonnet::EXT('resource.'.$$part{$which}.          my $sessionval=&Apache::lonnet::EXT('resource.'.$$part{$which}.
                                         '.'.$$name{$which},$$symbp{$rid});                                          '.'.$$name{$which},$$symbp{$rid});
         my $sessionvaltype=$typeoutpar[$result];          my $sessionvaltype=$typeoutpar[$result];
         if (!defined($sessionvaltype)) { $sessionvaltype=$$defaulttype{$which}; }          if (!defined($sessionvaltype)) {
               $sessionvaltype=$$defaulttype{$which};
           }
         $r->print('<td style="background-color:#999999;" align="center"><font color="#FFFFFF">'.          $r->print('<td style="background-color:#999999;" align="center"><font color="#FFFFFF">'.
                   &valout($sessionval,$sessionvaltype,$$name{$which}).'&nbsp;'.                    &valout($sessionval,$sessionvaltype,$$name{$which}).'&nbsp;'.
                   '</font></td>');                    '</font></td>');
     }      }
     $r->print('</tr>');      $r->print('</tr>');
     $r->print("\n");      $r->print("\n");
       if (($numlinks) && (ref($reclinks))) {
           $$reclinks = $numlinks;
       }
 }  }
   
   # Prints a cell for table mode.
   #
   # FIXME: some of these parameter names are uninspired ($which and $value)
   # Also, it would make more sense to pass the display for this cell rather
   # than the full display hash and the key to use.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {integer} $which - level
   # @param {string} $defbg - cell background color
   # @param {integer} $result - the most specific level that is defined for that parameter
   # @param {array reference} $outpar - array level -> parameter value (when defined)
   # @param {string} $mprefix - resource id.'&'.part.'_'.parameter name.'&'
   # @param {string} $value - parameter key ('parameter_'.part.'_'.name)
   # @param {array reference} $typeoutpar - array level -> parameter type (when defined)
   # @param {hash reference} $display - parameter key -> full title for the parameter
   # @param {boolean} $noeditgrp - true if no edit is allowed for group level parameters
   # @param {boolean} $readonly -true if editing not allowed.
   # @param {boolean} $ismaplevel - true if level is for a map. 
 sub print_td {  sub print_td {
     my ($r,$which,$defbg,$result,$outpar,$mprefix,$value,$typeoutpar,$display,$noeditgrp)=@_;      my ($r,$which,$defbg,$result,$outpar,$mprefix,$value,$typeoutpar,$display,
     $r->print('<td style="background-color:'.(($result==$which)?'#AAFFAA':$defbg).          $noeditgrp,$readonly,$ismaplevel)=@_;
       my ($ineffect,$recursive,$currval,$currtype,$currlevel);
       $ineffect = 0;
       $currval = $$outpar[$which];
       $currtype = $$typeoutpar[$which];
       $currlevel = $which;
       if (($result) && ($result == $which)) {
           $ineffect = 1;
       } 
       if ($ismaplevel) {
           if ($mprefix =~ /(hiddenresource|encrypturl)\&/) {
               if (($result) && ($result == $which)) {
                   $recursive = 1;
               }
           } elsif ($$outpar[$which+1] ne '') {
               $recursive = 1;
               $currlevel = $which+1;
               $currval = $$outpar[$currlevel];
               $currtype = $$typeoutpar[$currlevel];
               if (($result) && ($result == $currlevel)) {
                   $ineffect = 1;
               }
           }
       }
       $r->print('<td style="background-color:'.($ineffect?'#AAFFAA':$defbg).
               ';" align="center">');                ';" align="center">');
     my $nolink = 0;      my $nolink = 0;
     if ($which == 14 || $which == 15) {      if ($readonly) {
         $nolink = 1;  
     } elsif (($env{'request.course.sec'} ne '') && ($which > 12)) {  
         $nolink = 1;          $nolink = 1;
     } elsif ($which == 5 || $which ==  6 || $which == 7 || $which == 8) {      } else { 
         if ($noeditgrp) {          if ($which == 14 || $which == 15 || $mprefix =~ /mapalias\&$/) {
             $nolink = 1;  
         }  
     } elsif ($mprefix =~ /availablestudent\&$/) {  
         if ($which > 4) {  
             $nolink = 1;              $nolink = 1;
         }          } elsif (($env{'request.course.sec'} ne '') && ($which > 12)) {
     } elsif ($mprefix =~ /examcode\&$/) {  
         unless ($which == 2) {  
             $nolink = 1;              $nolink = 1;
           } elsif ($which == 5 || $which ==  6 || $which == 7 || $which == 8) {
               if ($noeditgrp) {
                   $nolink = 1;
               }
           } elsif ($mprefix =~ /availablestudent\&$/) {
               if ($which > 4) {
                   $nolink = 1;
               }
           } elsif ($mprefix =~ /examcode\&$/) {
               unless ($which == 2) {
                   $nolink = 1;
               }
         }          }
     }      }
     if ($nolink) {      if ($nolink) {
         $r->print(&valout($$outpar[$which],$$typeoutpar[$which],$mprefix));          my ($parmname)=((split(/\&/,$mprefix))[1]=~/\_([^\_]+)$/);
           $r->print(&valout($currval,$currtype,$parmname));
     } else {      } else {
         $r->print(&plink($$typeoutpar[$which],          $r->print(&plink($currtype,
                          $$display{$value},$$outpar[$which],                           $$display{$value},$currval,
                          $mprefix."$which",'parmform.pres','psub'));                           $mprefix.$currlevel,'parmform.pres','psub',$recursive));
     }      }
     $r->print('</td>'."\n");      $r->print('</td>'."\n");
 }  }
   
 sub print_usergroups {  # Returns HTML and other info for the cell added when a user is selected
     my ($r,$what,$rid,$cgroup,$defbg,$usersgroups,$result,$courseopt) = @_;  # and that user is in several groups. This is the cell with the title "Control by other group".
   #
   # @param {string} $what - parameter part.'.'.parameter name
   # @param {string} $rid - resource id
   # @param {string} $cgroup - group name
   # @param {string} $defbg - cell background color
   # @param {array reference} $usersgroups - list of groups the user belongs to, if any
   # @param {integer} $result - level
   # @param {hash reference} $courseopt - course parameters hash (result of lonnet::get_courseresdata, dump of course's resourcedata.db)
   # @returns {Array} - array (parameter value for the other group, HTML for the cell, HTML with the value, name of the other group, true if recursive)
   sub check_other_groups {
       my ($what,$rid,$cgroup,$defbg,$usersgroups,$result,$courseopt) = @_;
     my $courseid = $env{'request.course.id'};      my $courseid = $env{'request.course.id'};
     my $output;      my $output;
     my $symb = &symbcache($rid);      my $symb = &symbcache($rid);
Line 1381  sub print_usergroups { Line 1752  sub print_usergroups {
           &parm_control_group($courseid,$usersgroups,$symbparm,$mapparm,            &parm_control_group($courseid,$usersgroups,$symbparm,$mapparm,
                               $recurseparm,$what,$courseopt);                                $recurseparm,$what,$courseopt);
     my $bgcolor = $defbg;      my $bgcolor = $defbg;
     my $grp_parm;      my ($grp_parm,$grp_is_rec);
     if (($coursereply) && ($cgroup ne $resultgroup)) {      if (($coursereply) && ($cgroup ne $resultgroup)) {
           my ($parmname) = ($what =~ /\.([^.]+)$/);
         if ($result > 3) {          if ($result > 3) {
             $bgcolor = '#AAFFAA';              $bgcolor = '#AAFFAA';
             $grp_parm = &valout($coursereply,$resulttype,$what);  
         }          }
         $grp_parm = &valout($coursereply,$resulttype,$what);          $grp_parm = &valout($coursereply,$resulttype,$parmname);
         $output = '<td style="background-color:'.$bgcolor.';" align="center">';          $output = '<td style="background-color:'.$bgcolor.';" align="center">';
         if ($resultgroup && $resultlevel) {          if ($resultgroup && $resultlevel) {
             $output .= '<small><b>'.$resultgroup.'</b> ('.$resultlevel.'): </small>'.$grp_parm;              if ($resultlevel eq 'recursive') {
                   $resultlevel = 'map/folder';
                   $grp_is_rec = 1;
               }
               $output .= '<small><b>'.$resultgroup.'</b> ('.$resultlevel.'): </small>'.$grp_parm.
                          ($grp_is_rec?'<span class="LC_parm_recursive">'.&mt('recursive').'</span>':'');
                
         } else {          } else {
             $output .= '&nbsp;';              $output .= '&nbsp;';
         }          }
Line 1398  sub print_usergroups { Line 1775  sub print_usergroups {
     } else {      } else {
         $output .= '<td style="background-color:'.$bgcolor.';">&nbsp;</td>';          $output .= '<td style="background-color:'.$bgcolor.';">&nbsp;</td>';
     }      }
     return ($coursereply,$output,$grp_parm,$resultgroup);      return ($coursereply,$output,$grp_parm,$resultgroup,$grp_is_rec);
 }  }
   
   # Looks for a group with a defined parameter for given user and parameter.
   # Used by check_other_groups.
   #
   # @param {string} $courseid - the course id
   # @param {array reference} $usersgroups - list of groups the user belongs to, if any
   # @param {string} $symbparm - end of the course parameter hash key for the group resource level
   # @param {string} $mapparm - end of the course parameter hash key for the group map/folder level
   # @param {string} $recurseparm - end of the course parameter hash key for the group recursive level
   # @param {string} $what - parameter part.'.'.parameter name
   # @param {hash reference} $courseopt - course parameters hash
   # @returns {Array} - (parameter value for the group, course parameter hash key for the parameter, name of the group, level name, parameter type)
 sub parm_control_group {  sub parm_control_group {
     my ($courseid,$usersgroups,$symbparm,$mapparm,$recurseparm,$what,$courseopt) = @_;      my ($courseid,$usersgroups,$symbparm,$mapparm,$recurseparm,$what,$courseopt) = @_;
     my ($coursereply,$resultitem,$resultgroup,$resultlevel,$resulttype);      my ($coursereply,$resultitem,$resultgroup,$resultlevel,$resulttype);
Line 1427  sub parm_control_group { Line 1815  sub parm_control_group {
   
   
   
   # Extracts lots of information about all of the the course's resources into a variety of hashes, using lonnavmaps and lonnet::metadata.
   # All the parameters are references and are filled by the sub.
   #
   # @param {array reference} $ids - resource and map ids
   # @param {hash reference} $typep - hash resource/map id -> resource type (file extension)
   # @param {hash reference} $keyp - hash resource/map id -> comma-separated list of parameter keys from lonnet::metadata
   # @param {hash reference} $allparms - hash parameter name -> parameter title
   # @param {hash reference} $allparts - hash parameter part -> part title (a parameter part can be problem part.'_'.response id for response parameters)
   # @param {hash reference} $allmaps - hash map pc -> map src
   # @param {hash reference} $mapp - hash map pc or resource/map id -> enclosing map src
   # @param {hash reference} $symbp - hash map pc or resource/map id -> map src.'___(all)' for a map or resource symb for a resource
   # @param {hash reference} $maptitles - hash map pc or src -> map title (this should really be two separate hashes)
   # @param {hash reference} $uris - hash resource/map id -> resource src
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank for this parameter when looking through every resource and every parameter, starting at 100 (integer)
   # @param {hash reference} $defkeytype - hash parameter name -> parameter type
 sub extractResourceInformation {  sub extractResourceInformation {
     my $ids = shift;      my $ids = shift;
     my $typep = shift;      my $typep = shift;
Line 1526  sub extractResourceInformation { Line 1929  sub extractResourceInformation {
     }      }
 }  }
   
   sub get_recursive {
       my ($recurseup,$resdata,$what,$prefix) = @_; 
       if ((ref($resdata) eq 'HASH') && (ref($recurseup) eq 'ARRAY')) {
           foreach my $item (@{$recurseup}) {
               my $norecursechk=$prefix.'.'.$item.'___(all).'.$what;
               if (defined($resdata->{$norecursechk})) {
                   if ($what =~ /\.(encrypturl|hiddenresource)$/) {
                       my $type = $resdata->{$norecursechk.'.type'};
                       return [$resdata->{$norecursechk},$type,$item];
                   } else {
                       last;
                   }
               }
               my $recursechk=$prefix.'.'.$item.'___(rec).'.$what;
               if (defined($resdata->{$recursechk})) {
                   my $type = $resdata->{$recursechk.'.type'};
                   return [$resdata->{$recursechk},$type,$item];
               }
           }
       }
       return;
   }
   
   
   # Tells if a parameter type is a date.
   #
   # @param {string} type - parameter type
   # @returns{boolean} - true if it is a date
 sub isdateparm {  sub isdateparm {
     my $type=shift;      my $type=shift;
     return (($type=~/^date/) && (!($type eq 'date_interval')));      return (($type=~/^date/) && (!($type eq 'date_interval')));
 }  }
   
   # Prints the HTML and Javascript to select parameters, with various shortcuts.
 #  #
 # parmmenu displays a list of the selected parameters.  # @param {Apache2::RequestRec} $r - the Apache request
 # It also offers a link to show/hide the complete parameter list  
 # from which you can select all desired parameters.  
 #  
 sub parmmenu {  sub parmmenu {
     my ($r,$allparms,$pscat,$keyorder)=@_;      my ($r)=@_;
     my $tempkey;  
     $r->print(<<ENDSCRIPT);      $r->print(<<ENDSCRIPT);
 <script type="text/javascript">  <script type="text/javascript">
 // <![CDATA[  // <![CDATA[
Line 1553  sub parmmenu { Line 1979  sub parmmenu {
             displayOverview = "none"              displayOverview = "none"
         }          }
   
     for (i=0; i<document.forms.parmform.elements.length; i++) {          for (i=0; i<document.forms.parmform.elements.length; i++) {
             ele = document.forms.parmform.elements[i];              ele = document.forms.parmform.elements[i];
             if (ele.name == checkName) {              if (ele.name == checkName) {
                 document.forms.parmform.elements[i].checked=value;                  document.forms.parmform.elements[i].checked=value;
Line 1562  sub parmmenu { Line 1988  sub parmmenu {
     }      }
   
     function checkthis(thisvalue, checkName) {      function checkthis(thisvalue, checkName) {
           for (i=0; i<document.forms.parmform.elements.length; i++) {
   
     for (i=0; i<document.forms.parmform.elements.length; i++) {  
             ele = document.forms.parmform.elements[i];              ele = document.forms.parmform.elements[i];
             if (ele.name == checkName) {              if (ele.name == checkName) {
         if (ele.value == thisvalue) {                  if (ele.value == thisvalue) {
             document.forms.parmform.elements[i].checked=true;                      document.forms.parmform.elements[i].checked=true;
         }                  }
             }              }
         }          }
     }      }
   
     function checkdates() {      function checkdates() {
     checkthis('duedate','pscat');          checkthis('duedate','pscat');
      checkthis('opendate','pscat');          checkthis('opendate','pscat');
     checkthis('answerdate','pscat');          checkthis('answerdate','pscat');
     }      }
   
     function checkdisset() {      function checkdisset() {
      checkthis('discussend','pscat');          checkthis('discussend','pscat');
      checkthis('discusshide','pscat');          checkthis('discusshide','pscat');
      checkthis('discussvote','pscat');          checkthis('discussvote','pscat');
     }      }
   
     function checkcontdates() {      function checkcontdates() {
     checkthis('contentopen','pscat');          checkthis('contentopen','pscat');
      checkthis('contentclose','pscat');          checkthis('contentclose','pscat');
     }      }
   
     function checkvisi() {      function checkvisi() {
     checkthis('hiddenresource','pscat');          checkthis('hiddenresource','pscat');
      checkthis('encrypturl','pscat');          checkthis('encrypturl','pscat');
     checkthis('problemstatus','pscat');          checkthis('problemstatus','pscat');
     checkthis('contentopen','pscat');          checkthis('contentopen','pscat');
     checkthis('opendate','pscat');          checkthis('opendate','pscat');
     }      }
   
     function checkparts() {      function checkparts() {
     checkthis('hiddenparts','pscat');          checkthis('hiddenparts','pscat');
     checkthis('display','pscat');          checkthis('display','pscat');
     checkthis('ordered','pscat');          checkthis('ordered','pscat');
     }      }
   
     function checkstandard() {      function checkstandard() {
         checkall(false,'pscat');          checkall(false,'pscat');
     checkdates();          checkdates();
     checkthis('weight','pscat');          checkthis('weight','pscat');
     checkthis('maxtries','pscat');          checkthis('maxtries','pscat');
     checkthis('type','pscat');          checkthis('type','pscat');
     checkthis('problemstatus','pscat');          checkthis('problemstatus','pscat');
     }      }
   
 // ]]>  // ]]>
Line 1619  sub parmmenu { Line 2043  sub parmmenu {
 ENDSCRIPT  ENDSCRIPT
   
     $r->print('<hr />');      $r->print('<hr />');
     &shortCuts($r,$allparms,$pscat,$keyorder);      &shortCuts($r);
     $r->print('<hr />');      $r->print('<hr />');
 }  }
 # return a hash  
   # Returns parameter categories.
   #
   # @returns {hash} - category name -> title in English
 sub categories {  sub categories {
     return ('time_settings' => 'Time Settings',      return ('time_settings' => 'Time Settings',
     'grading' => 'Grading',      'grading' => 'Grading',
Line 1636  sub categories { Line 2063  sub categories {
     'misc' => 'Miscellaneous' );       'misc' => 'Miscellaneous' ); 
 }  }
   
 # return a hash. Like a look-up table  # Returns the category for each parameter.
   #
   # @returns {hash} - parameter name -> category name
 sub lookUpTableParameter {  sub lookUpTableParameter {
     
     return (       return ( 
Line 1647  sub lookUpTableParameter { Line 2076  sub lookUpTableParameter {
         'contentopen' => 'time_settings',          'contentopen' => 'time_settings',
         'contentclose' => 'time_settings',          'contentclose' => 'time_settings',
         'discussend' => 'time_settings',          'discussend' => 'time_settings',
  'printstartdate' => 'time_settings',          'printstartdate' => 'time_settings',
  'printenddate' => 'time_settings',          'printenddate' => 'time_settings',
         'weight' => 'grading',          'weight' => 'grading',
         'handgrade' => 'grading',          'handgrade' => 'grading',
         'maxtries' => 'tries',          'maxtries' => 'tries',
Line 1684  sub lookUpTableParameter { Line 2113  sub lookUpTableParameter {
         'retrypartial' => 'tries',          'retrypartial' => 'tries',
         'discussvote'  => 'misc',          'discussvote'  => 'misc',
         'examcode' => 'high_level_randomization',           'examcode' => 'high_level_randomization', 
     );          );
 }  }
   
   # Adds the given parameter name to an array of arrays listing all parameters for each category.
   #
   # @param {string} $name - parameter name
   # @param {array reference} $catList - array reference category name -> array reference of parameter names
 sub whatIsMyCategory {  sub whatIsMyCategory {
     my $name = shift;      my $name = shift;
     my $catList = shift;      my $catList = shift;
Line 1710  sub whatIsMyCategory { Line 2143  sub whatIsMyCategory {
     }              }        
 }  }
   
   # Sorts parameter names based on appearance order.
   #
   # @param {array reference} name - array reference of parameter names
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank
   # @returns {Array} - array of parameter names
 sub keysindisplayorderCategory {  sub keysindisplayorderCategory {
     my ($name,$keyorder)=@_;      my ($name,$keyorder)=@_;
     return sort {      return sort {
Line 1717  sub keysindisplayorderCategory { Line 2155  sub keysindisplayorderCategory {
     } ( @{$name});      } ( @{$name});
 }  }
   
   # Returns a hash category name -> order, starting at 1 (integer)
   #
   # @returns {hash}
 sub category_order {  sub category_order {
     return (      return (
         'time_settings' => 1,          'time_settings' => 1,
Line 1733  sub category_order { Line 2174  sub category_order {
   
 }  }
   
   # Prints HTML to let the user select parameters, from a list of all parameters organized by category.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {hash reference} $allparms - hash parameter name -> parameter title
   # @param {array reference} $pscat - list of selected parameter names
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank
 sub parmboxes {  sub parmboxes {
     my ($r,$allparms,$pscat,$keyorder)=@_;      my ($r,$allparms,$pscat,$keyorder)=@_;
     my %categories = &categories();      my %categories = &categories();
Line 1760  sub parmboxes { Line 2207  sub parmboxes {
         $r->print('<div class="LC_Box LC_400Box">'          $r->print('<div class="LC_Box LC_400Box">'
                  .'<h4 class="LC_hcell">'.&mt($categories{$key}).'</h4>'."\n");                   .'<h4 class="LC_hcell">'.&mt($categories{$key}).'</h4>'."\n");
         foreach my $tempkey (&keysindisplayorderCategory($categoryList{$key},$keyorder)) {          foreach my $tempkey (&keysindisplayorderCategory($categoryList{$key},$keyorder)) {
               next if ($tempkey eq '');
             $r->print('<span class="LC_nobreak">'              $r->print('<span class="LC_nobreak">'
                      .'<label><input type="checkbox" name="pscat" '                       .'<label><input type="checkbox" name="pscat" '
                      .'value="'.$tempkey.'" ');                       .'value="'.$tempkey.'" ');
Line 1774  sub parmboxes { Line 2222  sub parmboxes {
     }      }
     $r->print("\n");      $r->print("\n");
 }  }
   
   # Prints HTML with shortcuts to select groups of parameters in one click, or deselect all.
 #  #
 # This function offers some links on the parameter section to get with one click a group a parameters  # @param {Apache2::RequestRec} $r - the Apache request
 #  
 sub shortCuts {  sub shortCuts {
     my ($r,$allparms,$pscat,$keyorder)=@_;      my ($r)=@_;
   
     # Parameter Selection      # Parameter Selection
     $r->print(      $r->print(
Line 1809  sub shortCuts { Line 2258  sub shortCuts {
     );      );
 }  }
   
   # Prints HTML to select parts to view (except for the title).
   # Used by table and overview modes.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {hash reference} $allparts - hash parameter part -> part title
   # @param {array reference} $psprt - list of selected parameter parts
 sub partmenu {  sub partmenu {
     my ($r,$allparts,$psprt)=@_;      my ($r,$allparts,$psprt)=@_;
     my $selsize = 1+scalar(keys(%{$allparts}));      my $selsize = 1+scalar(keys(%{$allparts}));
Line 1818  sub partmenu { Line 2273  sub partmenu {
   
     $r->print('<select multiple="multiple" name="psprt" size="'.$selsize.'">');      $r->print('<select multiple="multiple" name="psprt" size="'.$selsize.'">');
     $r->print('<option value="all"');      $r->print('<option value="all"');
     $r->print(' selected="selected"') unless (@{$psprt});      $r->print(' selected="selected"') unless (@{$psprt}); # useless, the array is never empty
     $r->print('>'.&mt('All Parts').'</option>');      $r->print('>'.&mt('All Parts').'</option>');
     my %temphash=();      my %temphash=();
     foreach (@{$psprt}) { $temphash{$_}=1; }      foreach (@{$psprt}) { $temphash{$_}=1; }
     foreach my $tempkey (sort {      foreach my $tempkey (sort {
     if ($a==$b) { return ($a cmp $b) } else { return ($a <=> $b); }                  if ($a==$b) { return ($a cmp $b) } else { return ($a <=> $b); }
     } keys(%{$allparts})) {              } keys(%{$allparts})) {
     unless ($tempkey =~ /\./) {          unless ($tempkey =~ /\./) {
         $r->print('<option value="'.$tempkey.'"');              $r->print('<option value="'.$tempkey.'"');
         if ($$psprt[0] eq "all" ||  $temphash{$tempkey}) {              if ($$psprt[0] eq "all" ||  $temphash{$tempkey}) {
         $r->print(' selected="selected"');                  $r->print(' selected="selected"');
               }
               $r->print('>'.$$allparts{$tempkey}.'</option>');
         }          }
         $r->print('>'.$$allparts{$tempkey}.'</option>');  
     }  
     }      }
     $r->print('</select>');      $r->print('</select>');
 }  }
   
   # Prints HTML to select a user and/or a group.
   # Used by table mode.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {string} $uname - selected user name
   # @param {string} $id - selected Student/Employee ID
   # @param {string} $udom - selected user domain
   # @param {string} $csec - selected section name
   # @param {string} $cgroup - selected group name
   # @param {string} $parmlev - parameter level (Resource:'full', Map:'map', Course:'general')
   # @param {array reference} $usersgroups - list of groups the user belongs to, if any
   # @param {string} $pssymb - resource symb (when a single resource is selected)
 sub usermenu {  sub usermenu {
     my ($r,$uname,$id,$udom,$csec,$cgroup,$parmlev,$usersgroups,$pssymb)=@_;      my ($r,$uname,$id,$udom,$csec,$cgroup,$parmlev,$usersgroups,$pssymb)=@_;
     my $chooseopt=&Apache::loncommon::select_dom_form($udom,'udom').' '.      my $chooseopt=&Apache::loncommon::select_dom_form($udom,'udom').' '.
Line 1946  function group_or_section(caller) { Line 2413  function group_or_section(caller) {
                  ,$chooseopt));                   ,$chooseopt));
 }  }
   
   # Prints HTML to select parameters from a list of all parameters.
   # Uses parmmenu and parmboxes.
   # Used by table and overview modes.
 #  #
 # This function shows on table Mode the available Parameters for the selected Resources  # @param {Apache2::RequestRec} $r - the Apache request
 #  # @param {hash reference} $allparms - hash parameter name -> parameter title
   # @param {array reference} $pscat - list of selected parameter names
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank
   # @param {string} [$divid] - name used to give an id to the HTML element for the scroll box
 sub displaymenu {  sub displaymenu {
     my ($r,$allparms,$pscat,$psprt,$keyorder,$divid)=@_;      my ($r,$allparms,$pscat,$keyorder,$divid)=@_;
   
     $r->print(&Apache::lonhtmlcommon::start_pick_box());      $r->print(&Apache::lonhtmlcommon::start_pick_box());
     $r->print(&Apache::lonhtmlcommon::row_title(&mt('Select Parameters to View')));      $r->print(&Apache::lonhtmlcommon::row_title(&mt('Select Parameters to View')));
   
     &parmmenu($r,$allparms,$pscat,$keyorder);      &parmmenu($r);
     $r->print(&Apache::loncommon::start_scrollbox('480px','440px','200px',$divid));      $r->print(&Apache::loncommon::start_scrollbox('480px','440px','200px',$divid));
     &parmboxes($r,$allparms,$pscat,$keyorder);      &parmboxes($r,$allparms,$pscat,$keyorder);
     $r->print(&Apache::loncommon::end_scrollbox());      $r->print(&Apache::loncommon::end_scrollbox());
Line 1965  sub displaymenu { Line 2438  sub displaymenu {
     
 }  }
   
   # Prints HTML to select a map.
   # Used by table mode and overview mode.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {hash reference} $allmaps - hash map pc -> map src
   # @param {string} $pschp - selected map pc, or 'all'
   # @param {hash reference} $maptitles - hash map id or src -> map title
   # @param {hash reference} $symbp - hash map pc or resource/map id -> map src.'___(all)' or resource symb
 sub mapmenu {  sub mapmenu {
     my ($r,$allmaps,$pschp,$maptitles,$symbp)=@_;      my ($r,$allmaps,$pschp,$maptitles,$symbp)=@_;
     my %allmaps_inverted = reverse %$allmaps;      my %allmaps_inverted = reverse %$allmaps;
Line 2116  sub mapmenu { Line 2597  sub mapmenu {
     }      }
 }  }
   
 # Build up the select Box to choose if your parameter specification should work for the resource, map/folder or the course level  # Prints HTML to select the parameter level (resource, map/folder or course).
 # The value of default selection in the select box is set by the value that is given by the argument in $parmlev.  # Used by table and overview modes.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {hash reference} $alllevs - all parameter levels, hash English title -> value
   # @param {string} $parmlev - selected level value (full|map|general), or ''
 sub levelmenu {  sub levelmenu {
     my ($r,$alllevs,$parmlev)=@_;      my ($r,$alllevs,$parmlev)=@_;
   
Line 2135  sub levelmenu { Line 2620  sub levelmenu {
 }  }
   
   
   # Returns HTML to select a section (with a select HTML element).
   # Used by overview mode.
   #
   # @param {array reference} $selectedsections - list of selected section ids
   # @returns {string}
 sub sectionmenu {  sub sectionmenu {
     my ($selectedsections)=@_;      my ($selectedsections)=@_;
     my %sectionhash = &Apache::loncommon::get_sections();      my %sectionhash = &Apache::loncommon::get_sections();
Line 2160  sub sectionmenu { Line 2650  sub sectionmenu {
     return $output;      return $output;
 }  }
   
   # Returns HTML to select a group (with a select HTML element).
   # Used by overview mode.
   #
   # @param {array reference} $selectedgroups - list of selected group names
   # @returns {string}
 sub groupmenu {  sub groupmenu {
     my ($selectedgroups)=@_;      my ($selectedgroups)=@_;
     my %grouphash;      my %grouphash;
Line 2182  sub groupmenu { Line 2677  sub groupmenu {
     return $output;      return $output;
 }  }
   
   # Returns an array with the given parameter split by comma.
   # Used by assessparms (table mode).
   #
   # @param {string} $keyp - the string to split
   # @returns {Array<string>}
 sub keysplit {  sub keysplit {
     my $keyp=shift;      my $keyp=shift;
     return (split(/\,/,$keyp));      return (split(/\,/,$keyp));
 }  }
   
   # Returns the keys in $name, sorted using $keyorder.
   # Parameters are sorted by key, which means they are sorted by part first, then by name.
   # Used by assessparms (table mode) for resource level.
   #
   # @param {hash reference} $name - parameter key -> parameter name
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank
   # @returns {Array<string>}
 sub keysinorder {  sub keysinorder {
     my ($name,$keyorder)=@_;      my ($name,$keyorder)=@_;
     return sort {      return sort {
     $$keyorder{$a} <=> $$keyorder{$b};          $$keyorder{$a} <=> $$keyorder{$b};
     } (keys(%{$name}));      } (keys(%{$name}));
 }  }
   
   # Returns the keys in $name, sorted using $keyorder to sort parameters by name first, then by part.
   # Used by assessparms (table mode) for map and general levels.
   #
   # @param {hash reference} $name - parameter key -> parameter name
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank
   # @returns {Array<string>}
 sub keysinorder_bytype {  sub keysinorder_bytype {
     my ($name,$keyorder)=@_;      my ($name,$keyorder)=@_;
     return sort {      return sort {
     my $ta=(split('_',$a))[-1];          my $ta=(split('_',$a))[-1]; # parameter name
     my $tb=(split('_',$b))[-1];          my $tb=(split('_',$b))[-1];
     if ($$keyorder{'parameter_0_'.$ta} == $$keyorder{'parameter_0_'.$tb}) {          if ($$keyorder{'parameter_0_'.$ta} == $$keyorder{'parameter_0_'.$tb}) {
         return ($a cmp $b);              return ($a cmp $b);
     }          }
     $$keyorder{'parameter_0_'.$ta} <=> $$keyorder{'parameter_0_'.$tb};          $$keyorder{'parameter_0_'.$ta} <=> $$keyorder{'parameter_0_'.$tb};
     } (keys(%{$name}));      } (keys(%{$name}));
 }  }
   
   # Returns the keys in $name, sorted using $keyorder to sort parameters by name.
   # Used by defaultsetter (parameter settings default actions).
   #
   # @param {hash reference} $name - hash parameter name -> parameter title
   # @param {hash reference} $keyorder - hash parameter key -> appearance rank
   # @returns {Array<string>}
 sub keysindisplayorder {  sub keysindisplayorder {
     my ($name,$keyorder)=@_;      my ($name,$keyorder)=@_;
     return sort {      return sort {
     $$keyorder{'parameter_0_'.$a} <=> $$keyorder{'parameter_0_'.$b};          $$keyorder{'parameter_0_'.$a} <=> $$keyorder{'parameter_0_'.$b};
     } (keys(%{$name}));      } (keys(%{$name}));
 }  }
   
   # Prints HTML with a choice to sort results by realm or student first.
   # Used by overview mode.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {string} $sortorder - realmstudent|studentrealm
 sub sortmenu {  sub sortmenu {
     my ($r,$sortorder)=@_;      my ($r,$sortorder)=@_;
     $r->print('<br /><label><input type="radio" name="sortorder" value="realmstudent"');      $r->print('<br /><label><input type="radio" name="sortorder" value="realmstudent"');
Line 2228  sub sortmenu { Line 2752  sub sortmenu {
           '</label>');            '</label>');
 }  }
   
   # Returns a hash parameter key -> order (integer) giving the order for some parameters.
   #
   # @returns {hash}
 sub standardkeyorder {  sub standardkeyorder {
     return ('parameter_0_opendate' => 1,      return ('parameter_0_opendate' => 1,
         'parameter_0_duedate' => 2,          'parameter_0_duedate' => 2,
Line 2250  sub standardkeyorder { Line 2777  sub standardkeyorder {
         'parameter_0_discussend' => 19,          'parameter_0_discussend' => 19,
         'parameter_0_discusshide' => 20,          'parameter_0_discusshide' => 20,
         'parameter_0_discussvote' => 21,          'parameter_0_discussvote' => 21,
  'parameter_0_printstartdate'  =>  22,          'parameter_0_printstartdate'  =>  22,
  'parameter_0_printenddate' =>  23);          'parameter_0_printenddate' =>  23);
 }  }
   
   
   # Table mode UI.
   # If nothing is selected, prints HTML forms to select resources, parts, parameters, user, group and section.
   # Otherwise, prints the parameter table, with a link to change the selection unless a single resource is selected.
   #
   # Parameters used from the request:
   # action - handler action (see handler), usermenu is checking for value 'settable'
   # cgroup - selected group
   # command - 'set': direct access to table mode for a resource
   # csec - selected section
   # dis - set when the "Update Display" button was used, used only to discard command 'set'
   # hideparmsel - can be 'hidden' to hide the parameter selection div initially and display the "Change Parameter Selection" link instead (which displays the div)
   # id - student/employee ID
   # parmlev - selected level (full|map|general)
   # part - selected part (unused ?)
   # pres_marker - &&&-separated parameter identifiers, "resource id&part_parameter name&level"
   # pres_type - &&&-separated parameter types
   # pres_value - &&&-separated parameter values
   # prevvisit - '1' if the user has submitted the form before
   # pscat (multiple values) - selected parameter names
   # pschp - selected map pc, or 'all'
   # psprt (multiple values) - list of selected parameter parts
   # filter - part of or whole parameter name, to be filtered out when parameters are displayed (unused ?)
   # recent_* (* = parameter type) - recent values entered by the user for parameter types
   # symb - resource symb (when a single resource is selected)
   # udom - selected user domain
   # uname - selected user name
   # url - used only with command 'set', the resource url
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param $parm_permission - ref to hash of permissions
   #                           if $parm_permission->{'edit'} is true, editing is allowed.
 sub assessparms {  sub assessparms {
   
     my $r=shift;      my ($r,$parm_permission) = @_;
   
   
   
 # -------------------------------------------------------- Variable declaration  # -------------------------------------------------------- Variable declaration
     my @ids=();      my @ids=(); # resource and map ids
     my %symbp=();      my %symbp=(); # hash map pc or resource/map id -> map src.'___(all)' or resource symb
     my %mapp=();      my %mapp=(); # hash map pc or resource/map id -> enclosing map src
     my %typep=();      my %typep=(); # hash resource/map id -> resource type (file extension)
     my %keyp=();      my %keyp=(); # hash resource/map id -> comma-separated list of parameter keys
     my %uris=();      my %uris=(); # hash resource/map id -> resource src
     my %maptitles=();      my %maptitles=(); # hash map pc or src -> map title
     my %allmaps=();      my %allmaps=(); # hash map pc -> map src
     my %alllevs=();      my %allmaps_inverted=(); # hash map src -> map pc
       my %alllevs=(); # hash English level title -> value
     my $uname;  
     my $udom;      my $uname; # selected user name
     my $uhome;      my $udom; # selected user domain
     my $csec;      my $uhome; # server with the user's files, or 'no_host'
     my $cgroup;      my $csec; # selected section name
     my @usersgroups = ();      my $cgroup; # selected group name
       my @usersgroups = (); # list of the user groups
       my $numreclinks = 0;
   
     my $coursename=$env{'course.'.$env{'request.course.id'}.'.description'};      my $coursename=$env{'course.'.$env{'request.course.id'}.'.description'};
   
Line 2285  sub assessparms { Line 2844  sub assessparms {
     $alllevs{'Map/Folder Level'}='map';      $alllevs{'Map/Folder Level'}='map';
     $alllevs{'Course Level'}='general';      $alllevs{'Course Level'}='general';
   
     my %allparms;      my %allparms; # hash parameter name -> parameter title
     my %allparts;      my %allparts; # hash parameter part -> part title
 # ------------------------------------------------------------------------------  # ------------------------------------------------------------------------------
   
 #  #
Line 2344  sub assessparms { Line 2903  sub assessparms {
   
 # ----------------------------------------------- Was this started from grades?  # ----------------------------------------------- Was this started from grades?
   
     if (($env{'form.command'} eq 'set') && ($env{'form.url'})      if (($env{'form.command'} eq 'set') && ($env{'form.url'}) &&
     && (!$env{'form.dis'})) {              (!$env{'form.dis'})) {
         my $url=$env{'form.url'};          my $url=$env{'form.url'};
         $url=~s-^http://($ENV{'SERVER_NAME'}|$ENV{'HTTP_HOST'})--;          $url=~s-^http://($ENV{'SERVER_NAME'}|$ENV{'HTTP_HOST'})--;
         $pssymb=&Apache::lonnet::symbread($url);          $pssymb=&Apache::lonnet::symbread($url);
Line 2425  sub assessparms { Line 2984  sub assessparms {
                 \%mapp, \%symbp,\%maptitles,\%uris,                  \%mapp, \%symbp,\%maptitles,\%uris,
                 \%keyorder);                  \%keyorder);
   
       %allmaps_inverted = reverse(%allmaps);
   
     $mapp{'0.0'} = '';      $mapp{'0.0'} = '';
     $symbp{'0.0'} = '';      $symbp{'0.0'} = '';
   
 # ---------------------------------------------------------- Anything to store?  # ---------------------------------------------------------- Anything to store?
     if ($env{'form.pres_marker'}) {      if ($env{'form.pres_marker'} && $parm_permission->{'edit'}) {
         my @markers=split(/\&\&\&/,$env{'form.pres_marker'});          my @markers=split(/\&\&\&/,$env{'form.pres_marker'});
         my @values=split(/\&\&\&/,$env{'form.pres_value'});          my @values=split(/\&\&\&/,$env{'form.pres_value'});
         my @types=split(/\&\&\&/,$env{'form.pres_type'});          my @types=split(/\&\&\&/,$env{'form.pres_type'});
Line 2590  sub assessparms { Line 3151  sub assessparms {
         }          }
     }      }
 #----------------------------------------------- if all selected, fill in array  #----------------------------------------------- if all selected, fill in array
     if ($pscat[0] eq "all") {@pscat = (keys(%allparms));}      if ($pscat[0] eq "all") {
     if (!@pscat) { @pscat=('duedate','opendate','answerdate','weight','maxtries','type','problemstatus') };          @pscat = (keys(%allparms));
     if ($psprt[0] eq "all" || !@psprt) {@psprt = (keys(%allparts));}      }
       if (!@pscat) {
           @pscat=('duedate','opendate','answerdate','weight','maxtries','type','problemstatus')
       };
       if ($psprt[0] eq "all" || !@psprt) {
           @psprt = (keys(%allparts));
       }
 # ------------------------------------------------------------------ Start page  # ------------------------------------------------------------------ Start page
   
     my $crstype = &Apache::loncommon::course_type();      my $crstype = &Apache::loncommon::course_type();
     &startpage($r,$pssymb,$crstype);      &startpage($r,$pssymb,$crstype);
   
     foreach my $item ('tolerance','date_default','date_start','date_end',      foreach my $item ('tolerance','date_default','date_start','date_end',
         'date_interval','int','float','string') {              'date_interval','int','float','string') {
         $r->print('<input type="hidden" value="'.          $r->print('<input type="hidden" value="'.
           &HTML::Entities::encode($env{'form.recent_'.$item},'"&<>').              &HTML::Entities::encode($env{'form.recent_'.$item},'"&<>').
           '" name="recent_'.$item.'" />');              '" name="recent_'.$item.'" />');
     }      }
   
     # ----- Start Parameter Selection      # ----- Start Parameter Selection
Line 2612  sub assessparms { Line 3179  sub assessparms {
 <script type="text/javascript">  <script type="text/javascript">
 // <![CDATA[  // <![CDATA[
 function parmsel_show() {  function parmsel_show() {
   document.getElementById('parmsel').style.display = "";      document.getElementById('parmsel').style.display = "";
   document.getElementById('parmsellink').style.display = "none";      document.getElementById('parmsellink').style.display = "none";
 }  }
 // ]]>  // ]]>
 </script>  </script>
 ENDPARMSELSCRIPT  ENDPARMSELSCRIPT
           
     if (!$pssymb) {      if (!$pssymb) {
           # No single resource selected, print forms to select things (hidden after first selection)
         my $parmselhiddenstyle=' style="display:none"';          my $parmselhiddenstyle=' style="display:none"';
         if($env{'form.hideparmsel'} eq 'hidden') {          if($env{'form.hideparmsel'} eq 'hidden') {
            $r->print('<div id="parmsel"'.$parmselhiddenstyle.'>');             $r->print('<div id="parmsel"'.$parmselhiddenstyle.'>');
Line 2648  ENDPARMSELSCRIPT Line 3216  ENDPARMSELSCRIPT
   
         # Step 2          # Step 2
         $r->print(&Apache::lonhtmlcommon::topic_bar(2,&mt('Parameter Specification'),'parmstep2'));          $r->print(&Apache::lonhtmlcommon::topic_bar(2,&mt('Parameter Specification'),'parmstep2'));
         &displaymenu($r,\%allparms,\@pscat,\@psprt,\%keyorder,'parmmenuscroll');          &displaymenu($r,\%allparms,\@pscat,\%keyorder,'parmmenuscroll');
   
         # Step 3          # Step 3
         $r->print(&Apache::lonhtmlcommon::topic_bar(3,&mt('User Specification (optional)'),'parmstep3'));          $r->print(&Apache::lonhtmlcommon::topic_bar(3,&mt('User Specification (optional)'),'parmstep3'));
Line 2715  ENDPARMSELSCRIPT Line 3283  ENDPARMSELSCRIPT
         my @catmarker=map { tr|.|_|; 'parameter_'.$_; } @pscat;          my @catmarker=map { tr|.|_|; 'parameter_'.$_; } @pscat;
         my $csuname=$env{'user.name'};          my $csuname=$env{'user.name'};
         my $csudom=$env{'user.domain'};          my $csudom=$env{'user.domain'};
           my $readonly = 1;
           if ($parm_permission->{'edit'}) {
               undef($readonly); 
           }
   
         if ($parmlev eq 'full') {          if ($parmlev eq 'full') {
 #  #
 # This produces the cascading table output of parameters  # This produces the cascading table output of parameters
 #  #
                my $coursespan=$csec?10:6;              my $coursespan=$csec?8:5;
                my $userspan=4;              my $userspan=3;
                if ($cgroup ne '') {              if ($cgroup ne '') {
                   $coursespan += 4;                  $coursespan += 3;
                }              }
   
                $r->print(&Apache::loncommon::start_data_table());              $r->print(&Apache::loncommon::start_data_table());
 #              #
 # This produces the headers              # This produces the headers
 #              #
                $r->print('<tr><td colspan="5"></td>');              $r->print('<tr><td colspan="5"></td>');
                $r->print('<th colspan="'.($coursespan).'">'.&mt('Any User').'</th>');              $r->print('<th colspan="'.($coursespan).'">'.&mt('Any User').'</th>');
                if ($uname) {              if ($uname) {
                 if (@usersgroups > 1) {                  if (@usersgroups > 1) {
                        $userspan ++;                      $userspan ++;
                    }                  }
                    $r->print('<th colspan="'.$userspan.'" rowspan="2">');                  $r->print('<th colspan="'.$userspan.'" rowspan="2">');
                    $r->print(&mt('User [_1] at Domain [_2]',"'".$uname."'","'".$udom."'").'</th>');                  $r->print(&mt('User [_1] at Domain [_2]',"'".$uname."'","'".$udom."'").'</th>');
                }              }
                my %lt=&Apache::lonlocal::texthash(              my %lt=&Apache::lonlocal::texthash(
                 'pie'    => "Parameter in Effect",                  'pie'    => "Parameter in Effect",
                 'csv'    => "Current Session Value",                  'csv'    => "Current Session Value",
                 'rl'     => "Resource Level",                  'rl'     => "Resource Level",
Line 2753  ENDPARMSELSCRIPT Line 3325  ENDPARMSELSCRIPT
                 'femof'  => 'from Enclosing Map or Folder',                  'femof'  => 'from Enclosing Map or Folder',
                 'gen'    => 'general',                  'gen'    => 'general',
                 'foremf' => 'for Enclosing Map or Folder',                  'foremf' => 'for Enclosing Map or Folder',
                 'formfr' => 'for Map or Folder (recursive)',  
                 'fr'     => 'for Resource'                  'fr'     => 'for Resource'
             );              );
                $r->print(<<ENDTABLETWO);              $r->print(<<ENDTABLETWO);
 <th rowspan="3">$lt{'pie'}</th>  <th rowspan="3">$lt{'pie'}</th>
 <th rowspan="3">$lt{'csv'}<br />($csuname:$csudom)</th>  <th rowspan="3">$lt{'csv'}<br />($csuname:$csudom)</th>
 </tr><tr><td colspan="5"></td><th colspan="3">$lt{'ic'}</th><th colspan="2">$lt{'rl'}</th>  </tr><tr><td colspan="5"></td><th colspan="2">$lt{'ic'}</th><th colspan="2">$lt{'rl'}</th>
 <th colspan="1">$lt{'ic'}</th>  <th colspan="1">$lt{'ic'}</th>
   
 ENDTABLETWO  ENDTABLETWO
                if ($csec) {              if ($csec) {
                    $r->print('<th colspan="4">'.                  $r->print('<th colspan="3">'.
                   &mt("in Section")." $csec</th>");                  &mt("in Section")." $csec</th>");
                }              }
                if ($cgroup) {              if ($cgroup) {
                 $r->print('<th colspan="4">'.                  $r->print('<th colspan="3">'.
                 &mt("in Group")." $cgroup</th>");                  &mt("in Group")." $cgroup</th>");
                }              }
                $r->print(<<ENDTABLEHEADFOUR);              $r->print(<<ENDTABLEHEADFOUR);
 </tr><tr><th>$lt{'aut'}</th><th>$lt{'type'}</th>  </tr><tr><th>$lt{'aut'}</th><th>$lt{'type'}</th>
 <th>$lt{'emof'}</th><th>$lt{'part'}</th><th>$lt{'pn'}</th>  <th>$lt{'emof'}</th><th>$lt{'part'}</th><th>$lt{'pn'}</th>
 <th>$lt{'gen'}</th><th>$lt{'formfr'}</th><th>$lt{'foremf'}</th>  <th>$lt{'gen'}</th><th>$lt{'foremf'}</th>
 <th>$lt{'def'}</th><th>$lt{'femof'}</th><th>$lt{'fr'}</th>  <th>$lt{'def'}</th><th>$lt{'femof'}</th><th>$lt{'fr'}</th>
 ENDTABLEHEADFOUR  ENDTABLEHEADFOUR
   
                if ($csec) {              if ($csec) {
                    $r->print('<th>'.$lt{'gen'}.'</th><th>'.$lt{'formfr'}.'</th><th>'.$lt{'foremf'}.'</th><th>'.$lt{'fr'}.'</th>');                  $r->print('<th>'.$lt{'gen'}.'</th><th>'.$lt{'foremf'}.'</th><th>'.$lt{'fr'}.'</th>');
                }              }
   
                if ($cgroup) {              if ($cgroup) {
                    $r->print('<th>'.$lt{'gen'}.'</th><th>'.$lt{'formfr'}.'</th><th>'.&mt('foremf').'</th><th>'.$lt{'fr'}.'</th>');                  $r->print('<th>'.$lt{'gen'}.'</th><th>'.$lt{'foremf'}.'</th><th>'.$lt{'fr'}.'</th>');
                }              }
   
                if ($uname) {              if ($uname) {
                     if (@usersgroups > 1) {                  if (@usersgroups > 1) {
                         $r->print('<th>'.&mt('Control by other group?').'</th>');                      $r->print('<th>'.&mt('Control by other group?').'</th>');
                    }                  }
                    $r->print('<th>'.$lt{'gen'}.'</th><th>'.$lt{'formfr'}.'</th><th>'.$lt{'foremf'}.'</th><th>'.$lt{'fr'}.'</th>');                  $r->print('<th>'.$lt{'gen'}.'</th><th>'.$lt{'foremf'}.'</th><th>'.$lt{'fr'}.'</th>');
                }              }
   
                $r->print('</tr>');              $r->print('</tr>');
 #  #
 # Done with the headers  # Done with the headers
 #   # 
                my $defbgone='';              my $defbgone='';
                my $defbgtwo='';              my $defbgtwo='';
                my $defbgthree = '';              my $defbgthree = '';
   
                foreach my $rid (@ids) {              foreach my $rid (@ids) {
   
                 my ($inmapid)=($rid=~/\.(\d+)$/);                  my ($inmapid)=($rid=~/\.(\d+)$/);
   
                 if ((!$pssymb &&                  if ((!$pssymb &&
                  (($pschp eq 'all') || ($allmaps{$pschp} eq $mapp{$rid})))                          (($pschp eq 'all') || ($allmaps{$pschp} eq $mapp{$rid})))
                 ||                          ||
                 ($pssymb && $pssymb eq $symbp{$rid})) {                          ($pssymb && $pssymb eq $symbp{$rid})) {
 # ------------------------------------------------------ Entry for one resource  # ------------------------------------------------------ Entry for one resource
                     if ($defbgone eq '#E0E099') {                      if ($defbgone eq '#E0E099') {
                         $defbgone='#E0E0DD';                          $defbgone='#E0E0DD';
Line 2838  ENDTABLEHEADFOUR Line 3408  ENDTABLEHEADFOUR
                     my $filter=$env{'form.filter'};                      my $filter=$env{'form.filter'};
                     foreach my $tempkeyp (&keysplit($keyp{$rid})) {                      foreach my $tempkeyp (&keysplit($keyp{$rid})) {
                         if (grep $_ eq $tempkeyp, @catmarker) {                          if (grep $_ eq $tempkeyp, @catmarker) {
                           my $parmname=&Apache::lonnet::metadata($uri,$tempkeyp.'.name');                              my $parmname=&Apache::lonnet::metadata($uri,$tempkeyp.'.name');
 # We may only want certain parameters listed      # We may only want certain parameters listed
                           if ($filter) {                              if ($filter) {
                              unless ($filter=~/\Q$parmname\E/) { next; }                                  unless ($filter=~/\Q$parmname\E/) { next; }
                           }                              }
                           $name{$tempkeyp}=$parmname;                              $name{$tempkeyp}=$parmname;
                           $part{$tempkeyp}=&Apache::lonnet::metadata($uri,$tempkeyp.'.part');                              $part{$tempkeyp}=&Apache::lonnet::metadata($uri,$tempkeyp.'.part');
   
                           my $parmdis=&Apache::lonnet::metadata($uri,$tempkeyp.'.display');                              my $parmdis=&Apache::lonnet::metadata($uri,$tempkeyp.'.display');
                           if ($allparms{$name{$tempkeyp}} ne '') {                              if ($allparms{$name{$tempkeyp}} ne '') {
                               my $identifier;                                  my $identifier;
                               if ($parmdis =~ /(\s*\[Part.*)$/) {                                  if ($parmdis =~ /(\s*\[Part.*)$/) {
                                   $identifier = $1;                                      $identifier = $1;
                               }                                  }
                               $display{$tempkeyp} = $allparms{$name{$tempkeyp}}.$identifier;                                  $display{$tempkeyp} = $allparms{$name{$tempkeyp}}.$identifier;
                           } else {                              } else {
                               $display{$tempkeyp} = $parmdis;                                  $display{$tempkeyp} = $parmdis;
                           }                              }
                           unless ($display{$tempkeyp}) { $display{$tempkeyp}=''; }                              unless ($display{$tempkeyp}) { $display{$tempkeyp}=''; }
                           $display{$tempkeyp}.=' ('.$name{$tempkeyp}.')';                              $display{$tempkeyp}.=' ('.$name{$tempkeyp}.')';
                           $default{$tempkeyp}=&Apache::lonnet::metadata($uri,$tempkeyp);                              $default{$tempkeyp}=&Apache::lonnet::metadata($uri,$tempkeyp);
                           $type{$tempkeyp}=&Apache::lonnet::metadata($uri,$tempkeyp.'.type');                              $type{$tempkeyp}=&Apache::lonnet::metadata($uri,$tempkeyp.'.type');
                           $thistitle=&Apache::lonnet::metadata($uri,$tempkeyp.'.title');                              $thistitle=&Apache::lonnet::metadata($uri,$tempkeyp.'.title');
                         }                          }
                     }                      }
                     my $totalparms=scalar(keys(%name));                      my $totalparms=scalar(keys(%name));
                     if ($totalparms>0) {                      if ($totalparms>0) {
                            my $firstrow=1;                          my $firstrow=1;
                         my $title=&Apache::lonnet::gettitle($symbp{$rid});                          my $title=&Apache::lonnet::gettitle($symbp{$rid});
                           my $navmap = Apache::lonnavmaps::navmap->new();
                           my @recurseup;
                           if (ref($navmap) && $mapp{$rid}) {
                               @recurseup = $navmap->recurseup_maps($mapp{$rid});
                           }
                         $r->print('<tr><td style="background-color:'.$defbgone.';"'.                          $r->print('<tr><td style="background-color:'.$defbgone.';"'.
                              ' rowspan='.$totalparms.                               ' rowspan='.$totalparms.
                              '><tt><font size="-1">'.                               '><tt><font size="-1">'.
Line 2898  ENDTABLEHEADFOUR Line 3473  ENDTABLEHEADFOUR
                             &print_row($r,$item,\%part,\%name,\%symbp,$rid,\%default,                              &print_row($r,$item,\%part,\%name,\%symbp,$rid,\%default,
                                        \%type,\%display,$defbgone,$defbgtwo,                                         \%type,\%display,$defbgone,$defbgtwo,
                                        $defbgthree,$parmlev,$uname,$udom,$csec,                                         $defbgthree,$parmlev,$uname,$udom,$csec,
                                        $cgroup,\@usersgroups,$noeditgrp);                                         $cgroup,\@usersgroups,$noeditgrp,$readonly,
                                          \@recurseup,\%maptitles,\%allmaps_inverted,
                                          \$numreclinks);
                         }                          }
                     }                      }
                 }                  }
Line 2922  ENDTABLEHEADFOUR Line 3499  ENDTABLEHEADFOUR
   
 #-------------------------------------------- for each map, gather information  #-------------------------------------------- for each map, gather information
             my $mapid;              my $mapid;
                foreach $mapid (sort {$maplist{$a} cmp $maplist{$b}} keys(%maplist)) {              foreach $mapid (sort {$maplist{$a} cmp $maplist{$b}} keys(%maplist)) {
                 my $maptitle = $maplist{$mapid};                  my $maptitle = $maplist{$mapid};
   
 #-----------------------  loop through ids and get all parameter types for map  #-----------------------  loop through ids and get all parameter types for map
Line 2942  ENDTABLEHEADFOUR Line 3519  ENDTABLEHEADFOUR
   
 #                  $r->print("$mapid:$map:   $rid <br /> \n");  #                  $r->print("$mapid:$map:   $rid <br /> \n");
   
                      if ($map eq $mapid) {                      if ($map eq $mapid) {
                         my $uri=&Apache::lonnet::declutter($uris{$rid});                          my $uri=&Apache::lonnet::declutter($uris{$rid});
   
 #                    $r->print("Keys: $keyp{$rid} <br />\n");  #                    $r->print("Keys: $keyp{$rid} <br />\n");
   
 #--------------------------------------------------------------------  #--------------------------------------------------------------------
Line 2977  ENDTABLEHEADFOUR Line 3555  ENDTABLEHEADFOUR
                                 $type{$tempkeyp}=&Apache::lonnet::metadata($uri,$fullkeyp.'.type');                                  $type{$tempkeyp}=&Apache::lonnet::metadata($uri,$fullkeyp.'.type');
                               }                                }
                         } # end loop through keys                          } # end loop through keys
                       }                      }
                 } # end loop through ids                  } # end loop through ids
   
 #---------------------------------------------------- print header information  #---------------------------------------------------- print header information
Line 3011  ENDTABLEHEADFOUR Line 3589  ENDTABLEHEADFOUR
                 $r->print('<p>'.&Apache::loncommon::start_data_table()                  $r->print('<p>'.&Apache::loncommon::start_data_table()
                          .&Apache::loncommon::start_data_table_header_row()                           .&Apache::loncommon::start_data_table_header_row()
                          .'<th>'.&mt('Parameter Name').'</th>'                           .'<th>'.&mt('Parameter Name').'</th>'
                          .'<th>'.&mt('Recursive Value').'</th>'                           .'<th>'.&mt('Value').'</th>'
                          .'<th>'.&mt('Non-Recursive Value').'</th>'  
                          .'<th>'.&mt('Parameter in Effect').'</th>'                           .'<th>'.&mt('Parameter in Effect').'</th>'
                          .&Apache::loncommon::end_data_table_header_row()                           .&Apache::loncommon::end_data_table_header_row()
                 );                  );
   
                   my $navmap = Apache::lonnavmaps::navmap->new();
                   my @recurseup;
                   if (ref($navmap)) {
                        my $mapres = $navmap->getByMapPc($mapid);
                        if (ref($mapres)) {
                            @recurseup = $navmap->recurseup_maps($mapres->src());
                        }
                   }
   
   
                 foreach my $item (&keysinorder(\%name,\%keyorder)) {                  foreach my $item (&keysinorder(\%name,\%keyorder)) {
                     $r->print(&Apache::loncommon::start_data_table_row());                      $r->print(&Apache::loncommon::start_data_table_row());
                     &print_row($r,$item,\%part,\%name,\%symbp,$mapid,\%default,                      &print_row($r,$item,\%part,\%name,\%symbp,$mapid,\%default,
                            \%type,\%display,$defbgone,$defbgtwo,$defbgthree,                             \%type,\%display,$defbgone,$defbgtwo,$defbgthree,
                            $parmlev,$uname,$udom,$csec,$cgroup,'',$noeditgrp);                             $parmlev,$uname,$udom,$csec,$cgroup,'',$noeditgrp,
                              $readonly,\@recurseup,\%maptitles,\%allmaps_inverted,
                              \$numreclinks);
                 }                  }
                 $r->print(&Apache::loncommon::end_data_table().'</p>'                  $r->print(&Apache::loncommon::end_data_table().'</p>'
                          .'</div>'                           .'</div>'
Line 3077  ENDTABLEHEADFOUR Line 3666  ENDTABLEHEADFOUR
                         $display{$tempkeyp} =~ s/_\w+_/_0_/;                          $display{$tempkeyp} =~ s/_\w+_/_0_/;
                         $default{$tempkeyp}=&Apache::lonnet::metadata($uri,$fullkeyp);                          $default{$tempkeyp}=&Apache::lonnet::metadata($uri,$fullkeyp);
                         $type{$tempkeyp}=&Apache::lonnet::metadata($uri,$fullkeyp.'.type');                          $type{$tempkeyp}=&Apache::lonnet::metadata($uri,$fullkeyp.'.type');
                       }                      }
                 } # end loop through keys                  } # end loop through keys
             } # end loop through ids              } # end loop through ids
   
Line 3110  ENDMAPONE Line 3699  ENDMAPONE
             foreach my $item (&keysinorder(\%name,\%keyorder)) {              foreach my $item (&keysinorder(\%name,\%keyorder)) {
                 $r->print(&Apache::loncommon::start_data_table_row());                  $r->print(&Apache::loncommon::start_data_table_row());
                 &print_row($r,$item,\%part,\%name,\%symbp,$mapid,\%default,                  &print_row($r,$item,\%part,\%name,\%symbp,$mapid,\%default,
                        \%type,\%display,$defbgone,$defbgtwo,$defbgthree,                             \%type,\%display,$defbgone,$defbgtwo,$defbgthree,
                                    $parmlev,$uname,$udom,$csec,$cgroup,'',$noeditgrp);                             $parmlev,$uname,$udom,$csec,$cgroup,'',$noeditgrp,
                              $readonly);
             }              }
             $r->print(&Apache::loncommon::end_data_table()              $r->print(&Apache::loncommon::end_data_table()
                      .'</p>'                       .'</p>'
Line 3120  ENDMAPONE Line 3710  ENDMAPONE
         } # end of $parmlev eq general          } # end of $parmlev eq general
     }      }
     $r->print('</form>');      $r->print('</form>');
       if ($numreclinks) {
           $r->print(<<"END");
   <form name="recurseform" action="/adm/parmset?action=settable" method="post">
   <input type="hidden" name="pschp" />
   <input type="hidden" name="pscat" />
   <input type="hidden" name="psprt" />
   <input type="hidden" name="hideparmsel" value="hidden" />
   </form>
   <script type="text/javascript">
   function pjumprec(rid,name,part) {
       document.forms.recurseform.pschp.value = rid;
       document.forms.recurseform.pscat.value = name;
       document.forms.recurseform.psprt.value = part;
       document.forms.recurseform.submit();
       return false;
   }
   </script>
   END
       }
     &endSettingsScreen($r);      &endSettingsScreen($r);
     $r->print(&Apache::loncommon::end_page());      $r->print(&Apache::loncommon::end_page());
 } # end sub assessparms  } # end sub assessparms
   
   
   
 ##################################################  ##################################################
 # Overview mode  # OVERVIEW MODE
 ##################################################  ##################################################
 my $tableopen;  
   
   my $tableopen; # boolean, true if HTML table is already opened
   
   # Returns HTML with the HTML table start tag and header, unless the table is already opened.
   # @param {boolean} $readonly - true if values cannot be edited (otherwise more columns are added)
   # @returns {string}
 sub tablestart {  sub tablestart {
     my ($readonly) = @_;      my ($readonly,$is_map) = @_;
     if ($tableopen) {      if ($tableopen) {
         return '';          return '';
     } else {      } else {
Line 3139  sub tablestart { Line 3754  sub tablestart {
         if ($readonly) {          if ($readonly) {
             $output .= '<th>'.&mt('Current value').'</th>';              $output .= '<th>'.&mt('Current value').'</th>';
         } else {          } else {
             $output .= '<th>'.&mt('Delete').'</th><th>'.&mt('Set to ...').'</th>';              $output .= '<th>'.&mt('Delete').'</th>'.
                          '<th>'.&mt('Set to ...').'</th>';
               if ($is_map) {
                   $output .= '<th>'.&mt('Recursive?').'</th>';
               }
         }          }
         $output .= '</tr>';          $output .= '</tr>';
         return $output;          return $output;
     }      }
 }  }
   
   # Returns HTML with the HTML table end tag, unless the table is not opened.
   # @returns {string}
 sub tableend {  sub tableend {
     if ($tableopen) {      if ($tableopen) {
     $tableopen=0;          $tableopen=0;
     return &Apache::loncommon::end_data_table();          return &Apache::loncommon::end_data_table();
     } else {      } else {
     return'';          return'';
     }      }
 }  }
   
   # Reads course and user information.
   # If the context is looking for a scalar, returns the course parameters hash (result of lonnet::get_courseresdata, dump of course's resourcedata.db) with added student data from lonnet::get_userresdata (which reads the user's resourcedata.db).
   # The key for student data is modified with '[useropt:'.username.':'.userdomain.'].'.
   # If the context is looking for a list, returns a list with the scalar data and the class list.
   # @param {string} $crs - course number
   # @param {string} $dom - course domain
   # @returns {hash reference|Array}
 sub readdata {  sub readdata {
     my ($crs,$dom)=@_;      my ($crs,$dom)=@_;
 # Read coursedata  # Read coursedata
Line 3183  sub readdata { Line 3811  sub readdata {
 }  }
   
   
 # Setting  # Stores parameter data, using form parameters directly.
   #
   # Uses the following form parameters. The variable part in the names is a resourcedata key (except for a modification for user data).
   # set_* (except settext, setipallow, setipdeny) - set a parameter value
   # del_* - remove a parameter
   # datepointer_* - set a date parameter (value is key_* refering to a set of other form parameters)
   # dateinterval_* - set a date interval parameter (value refers to more form parameters)
   # key_* - date values
   # days_* - for date intervals
   # hours_* - for date intervals
   # minutes_* - for date intervals
   # seconds_* - for date intervals
   # done_* - for date intervals
   # typeof_* - parameter type
   # 
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {string} $crs - course number
   # @param {string} $dom - course domain
 sub storedata {  sub storedata {
     my ($r,$crs,$dom)=@_;      my ($r,$crs,$dom)=@_;
 # Set userlevel immediately  # Set userlevel immediately
Line 3193  sub storedata { Line 3837  sub storedata {
     my %newdata=();      my %newdata=();
     undef %newdata;      undef %newdata;
     my @deldata=();      my @deldata=();
       my @delrec=();
       my @delnonrec=();
     undef @deldata;      undef @deldata;
     my ($got_chostname,$chostname,$cmajor,$cminor);      my ($got_chostname,$chostname,$cmajor,$cminor);
     my $now = time;      my $now = time;
     foreach my $key (keys(%env)) {       foreach my $key (keys(%env)) {
     if ($key =~ /^form\.([a-z]+)\_(.+)$/) {          if ($key =~ /^form\.([a-z]+)\_(.+)$/) {
         my $cmd=$1;              my $cmd=$1;
         my $thiskey=$2;              my $thiskey=$2;
         next if ($cmd eq 'settext' || $cmd eq 'setipallow' || $cmd eq 'setipdeny');              my ($altkey,$recursive,$tkey,$tkeyrec,$tkeynonrec);
         my ($tuname,$tudom)=&extractuser($thiskey);              next if ($cmd eq 'rec' || $cmd eq 'settext' || $cmd eq 'setipallow' || $cmd eq 'setipdeny');
         my $tkey=$thiskey;              if ((($cmd eq 'set') || ($cmd eq 'datepointer') || ($cmd eq 'dateinterval') || ($cmd eq 'del')) && 
                    ($thiskey =~ /(?:sequence|page)\Q___(all)\E/)) {
                   unless ($thiskey =~ /(encrypturl|hiddenresource)$/) {
                       $altkey = $thiskey;
                       $altkey =~ s/\Q___(all)\E/___(rec)/;
                       if ($env{'form.rec_'.$thiskey}) {
                           $recursive = 1;
                       }
                   }
               }
               my ($tuname,$tudom)=&extractuser($thiskey);
             if ($tuname) {              if ($tuname) {
         $tkey=~s/\.\[useropt\:$tuname\:$tudom\]\./\./;                  $tkey=$thiskey;
         }                  $tkey=~s/\.\[useropt\:$tuname\:$tudom\]\./\./;
         if ($cmd eq 'set' || $cmd eq 'datepointer' || $cmd eq 'dateinterval') {                  if ($altkey) {
         my ($data, $typeof, $text, $name, $valchk, $valmatch, $namematch);                      $tkeynonrec = $tkey; 
         if ($cmd eq 'set') {                      $tkeyrec = $altkey;
             $data=$env{$key};                      $tkeyrec=~s/\.\[useropt\:$tuname\:$tudom\]\./\./;
             $valmatch = '';                  }
             $valchk = $data;              }
             $typeof=$env{'form.typeof_'.$thiskey};              if ($cmd eq 'set' || $cmd eq 'datepointer' || $cmd eq 'dateinterval') {
             $text = &mt('Saved modified parameter for');                  my ($data, $typeof, $text, $name, $valchk, $valmatch, $namematch);
             if ($typeof eq 'string_questiontype') {                  if ($cmd eq 'set') {
                 $name = 'type';                      $data=$env{$key};
             } elsif ($typeof eq 'string_lenient') {                      $valmatch = '';
                 $name = 'lenient';                      $valchk = $data;
                 my $stringmatch = &standard_string_matches($typeof);                      $typeof=$env{'form.typeof_'.$thiskey};
                 if (ref($stringmatch) eq 'ARRAY') {                      $text = &mt('Saved modified parameter for');
                     foreach my $item (@{$stringmatch}) {                      if ($typeof eq 'string_questiontype') {
                         if (ref($item) eq 'ARRAY') {                          $name = 'type';
                             my ($regexpname,$pattern) = @{$item};                      } elsif ($typeof eq 'string_lenient') {
                             if ($pattern ne '') {                          $name = 'lenient';
                                 if ($data =~ /$pattern/) {                          my $stringmatch = &standard_string_matches($typeof);
                                     $valmatch = $regexpname;                          if (ref($stringmatch) eq 'ARRAY') {
                                     $valchk = '';                              foreach my $item (@{$stringmatch}) {
                                     last;                                  if (ref($item) eq 'ARRAY') {
                                       my ($regexpname,$pattern) = @{$item};
                                       if ($pattern ne '') {
                                           if ($data =~ /$pattern/) {
                                               $valmatch = $regexpname;
                                               $valchk = '';
                                               last;
                                           }
                                       }
                                 }                                  }
                             }                              }
                         }                          }
                       } elsif ($typeof eq 'string_discussvote') {
                           $name = 'discussvote';
                       } elsif ($typeof eq 'string_examcode') {
                           $name = 'examcode';
                           if (&Apache::lonnet::validCODE($data)) {
                               $valchk = 'valid';
                           }
                       } elsif ($typeof eq 'string_yesno') {
                           if ($thiskey =~ /\.retrypartial$/) {
                               $name = 'retrypartial';
                           }
                     }                      }
                 }                  } elsif ($cmd eq 'datepointer') {
             } elsif ($typeof eq 'string_discussvote') {                      $data=&Apache::lonhtmlcommon::get_date_from_form($env{$key});
                 $name = 'discussvote';                      $typeof=$env{'form.typeof_'.$thiskey};
             } elsif ($typeof eq 'string_examcode') {                      $text = &mt('Saved modified date for');
                 $name = 'examcode';                      if ($typeof eq 'date_start') {
                 if (&Apache::lonnet::validCODE($data)) {                          if ($thiskey =~ /\.printstartdate$/) {
                     $valchk = 'valid';                              $name = 'printstartdate';
                 }                              if (($data) && ($data > $now)) {
             } elsif ($typeof eq 'string_yesno') {                                  $valchk = 'future';
                 if ($thiskey =~ /\.retrypartial$/) {                              }
                     $name = 'retrypartial';                          }
                 }                      } elsif ($typeof eq 'date_end') {
             }                          if ($thiskey =~ /\.printenddate$/) {
         } elsif ($cmd eq 'datepointer') {                              $name = 'printenddate';
             $data=&Apache::lonhtmlcommon::get_date_from_form($env{$key});                              if (($data) && ($data < $now)) {
             $typeof=$env{'form.typeof_'.$thiskey};                                  $valchk = 'past';
             $text = &mt('Saved modified date for');                              }
             if ($typeof eq 'date_start') {                          }
                 if ($thiskey =~ /\.printstartdate$/) {  
                     $name = 'printstartdate';  
                     if (($data) && ($data > $now)) {  
                         $valchk = 'future';  
                     }  
                 }  
             } elsif ($typeof eq 'date_end') {  
                 if ($thiskey =~ /\.printenddate$/) {  
                     $name = 'printenddate';  
                     if (($data) && ($data < $now)) {  
                         $valchk = 'past';  
                     }                      }
                 }                  } elsif ($cmd eq 'dateinterval') {
             }                      $data=&get_date_interval_from_form($thiskey);
         } elsif ($cmd eq 'dateinterval') {                      if ($thiskey =~ /\.interval$/) {
             $data=&get_date_interval_from_form($thiskey);                          $name = 'interval';
             if ($thiskey =~ /\.interval$/) {                          my $intervaltype = &get_intervaltype($name);
                 $name = 'interval';                          my $intervalmatch = &standard_interval_matches($intervaltype);
                 my $intervaltype = &get_intervaltype($name);                          if (ref($intervalmatch) eq 'ARRAY') {
                 my $intervalmatch = &standard_interval_matches($intervaltype);                              foreach my $item (@{$intervalmatch}) {
                 if (ref($intervalmatch) eq 'ARRAY') {                                  if (ref($item) eq 'ARRAY') {
                     foreach my $item (@{$intervalmatch}) {                                      my ($regexpname,$pattern) = @{$item};
                         if (ref($item) eq 'ARRAY') {                                      if ($pattern ne '') {
                             my ($regexpname,$pattern) = @{$item};                                          if ($data =~ /$pattern/) {
                             if ($pattern ne '') {                                              $valmatch = $regexpname;
                                 if ($data =~ /$pattern/) {                                              $valchk = '';
                                     $valmatch = $regexpname;                                              last;
                                     $valchk = '';                                          }
                                     last;                                      }
                                 }                                  }
                             }                              }
                         }                          }
                     }                      }
                       $typeof=$env{'form.typeof_'.$thiskey};
                       $text = &mt('Saved modified date for');
                 }                  }
             }                  if ($recursive) {
             $typeof=$env{'form.typeof_'.$thiskey};                      $namematch = 'maplevelrecurse';
             $text = &mt('Saved modified date for');                  }
         }                  if (($name ne '') || ($namematch ne '')) {
         if ($thiskey =~ m{\.(?:sequence|page)___\(rec\)}) {                      my ($needsrelease,$needsnewer);
             $namematch = 'maplevelrecurse';                      if ($name ne '') {
         }                          $needsrelease = $Apache::lonnet::needsrelease{"parameter:$name:$valchk:$valmatch:"};
         if (($name ne '') || ($namematch ne '')) {                          if ($needsrelease) {
             my ($needsrelease,$needsnewer);                              unless ($got_chostname) {
             if ($name ne '') {                                  ($chostname,$cmajor,$cminor)=&parameter_release_vars();
                 $needsrelease = $Apache::lonnet::needsrelease{"parameter:$name:$valchk:$valmatch:"};                                  $got_chostname = 1;
                 if ($needsrelease) {                              }
                     unless ($got_chostname) {                              $needsnewer = &parameter_releasecheck($name,$valchk,$valmatch,undef,
                         ($chostname,$cmajor,$cminor)=&parameter_release_vars();                                                                  $needsrelease,
                         $got_chostname = 1;                                                                  $cmajor,$cminor);
                           }
                       }
                       if ($namematch ne '') {
                           if ($needsnewer) {
                               undef($namematch);
                           } else {
                               my $currneeded;
                               if ($needsrelease) {
                                   $currneeded = $needsrelease;
                               }
                               $needsrelease =
                                   $Apache::lonnet::needsrelease{"parameter::::$namematch"};
                               if (($needsrelease) &&
                                       (($currneeded eq '') || ($needsrelease < $currneeded))) {
                                   unless ($got_chostname) {
                                       ($chostname,$cmajor,$cminor) = &parameter_release_vars();
                                       $got_chostname = 1;
                                   }
                                   $needsnewer = &parameter_releasecheck(undef,$valchk,$valmatch,
                                       $namematch, $needsrelease,$cmajor,$cminor);
                               } else {
                                   undef($namematch);
                               }
                           }
                       }
                       if ($needsnewer) {
                           $r->print('<br />'.&oldversion_warning($name,$namematch,$data,
                                                               $chostname,$cmajor,
                                                               $cminor,$needsrelease));
                           next;
                     }                      }
                     $needsnewer = &parameter_releasecheck($name,$valchk,$valmatch,undef,  
                                                           $needsrelease,  
                                                           $cmajor,$cminor);  
                 }                  }
             }                  my ($reconlychg,$haschange,$storekey);
             if ($namematch ne '') {                  if ($tuname) {
                 if ($needsnewer) {                      my $ustorekey;
                     undef($namematch);                      if ($altkey) {
                           if ($recursive) {
                               if (exists($$olddata{$thiskey})) {
                                   if ($$olddata{$thiskey} eq $data) {
                                       $reconlychg = 1;
                                   }
                                   &Apache::lonnet::del('resourcedata',[$tkeynonrec,$tkeynonrec.'.type'],$tudom,$tuname);
                               }
                               if (exists($$olddata{$altkey})) {
                                   if (defined($data) && $$olddata{$altkey} ne $data) {
                                       $haschange = 1;
                                   }
                               } elsif ((!$reconlychg) && ($data ne '')) {
                                   $haschange = 1;
                               }
                               $ustorekey = $tkeyrec;
                           } else {
                               if (exists($$olddata{$altkey})) {
                                   if ($$olddata{$altkey} eq $data) {
                                       $reconlychg = 1;
                                   }
                                   &Apache::lonnet::del('resourcedata',[$tkeyrec,$tkeyrec.'.type'],$tudom,$tuname);
                               }
                               if (exists($$olddata{$thiskey})) {
                                   if (defined($data) && $$olddata{$thiskey} ne $data) {
                                       $haschange = 1;
                                   }
                               } elsif ((!$reconlychg) && ($data ne '')) {
                                   $haschange = 1;
                               }
                               $ustorekey = $tkeynonrec;
                           }
                       } else {
                           if (exists($$olddata{$tkey})) {
                               if (defined($data) && $$olddata{$tkey} ne $data) {
                                   $haschange = 1;
                               }
                               $ustorekey = $tkey;
                           }
                       }
                       if ($haschange || $reconlychg)  {
                           unless ($env{'form.del_'.$thiskey}) {
                               if (&Apache::lonnet::put('resourcedata',{$ustorekey=>$data,
                                                                        $ustorekey.'.type' => $typeof},
                                                                        $tudom,$tuname) eq 'ok') {
                                   &log_parmset({$ustorekey=>$data,$ustorekey.'.type' => $typeof},0,$tuname,$tudom);
                                   $r->print('<br />'.$text.' '.
                                             &Apache::loncommon::plainname($tuname,$tudom));
                               } else {
                                   $r->print('<div class="LC_error">'.
                                             &mt('Error saving parameters').'</div>');
                               }
                               &Apache::lonnet::devalidateuserresdata($tuname,$tudom);
                           }
                       }
                 } else {                  } else {
                     my $currneeded;                      if ($altkey) {
                     if ($needsrelease) {                          if ($recursive) {
                         $currneeded = $needsrelease;                              if (exists($$olddata{$thiskey})) {
                                   if ($$olddata{$thiskey} eq $data) {
                                       $reconlychg = 1;
                                   }
                                   push(@delnonrec,($thiskey,$thiskey.'.type'));
                               }
                               if (exists($$olddata{$altkey})) {
                                   if (defined($data) && $$olddata{$altkey} ne $data) {
                                       $haschange = 1;
                                   }
                               } elsif (($data ne '') && (!$reconlychg)) {
                                   $haschange = 1;
                               }
                               $storekey = $altkey;
                           } else {
                               if (exists($$olddata{$altkey})) {
                                   if ($$olddata{$altkey} eq $data) {
                                       $reconlychg = 1;
                                   }
                                   push(@delrec,($altkey,$altkey.'.type'));
                               } 
                               if (exists($$olddata{$thiskey})) {
                                   if (defined($data) && $$olddata{$thiskey} ne $data) {
                                       $haschange = 1;
                                   }
                               } elsif (($data ne '') && (!$reconlychg)) {
                                   $haschange = 1;
                               }
                               $storekey = $thiskey;
                           }
                       } else {
                           if (defined($data) && $$olddata{$thiskey} ne $data) {
                               $haschange = 1;
                               $storekey = $thiskey;
                           }
                     }                      }
                     $needsrelease =                  }
                         $Apache::lonnet::needsrelease{"parameter::::$namematch"};                  if ($reconlychg || $haschange) {
                     if (($needsrelease) && (($currneeded eq '') || ($needsrelease < $currneeded))) {                      unless ($env{'form.del_'.$thiskey}) {
                         unless ($got_chostname) {                          $newdata{$storekey}=$data;
                             ($chostname,$cmajor,$cminor) = &parameter_release_vars();                          $newdata{$storekey.'.type'}=$typeof;
                             $got_chostname = 1;                      }
                   }
               } elsif ($cmd eq 'del') {
                   if ($tuname) {
                       my $error;
                       if ($altkey) {  
                           if (exists($$olddata{$altkey})) {
                               if (&Apache::lonnet::del('resourcedata',[$tkeyrec,$tkeyrec.'.type'],$tudom,$tuname) eq 'ok') {
                                   &log_parmset({$tkeyrec=>''},1,$tuname,$tudom);
                                   if ($recursive) {
                                       $r->print('<br />'.&mt('Deleted parameter for').' '.&Apache::loncommon::plainname($tuname,$tudom));
                                   }
                               } elsif ($recursive) {
                                   $error = 1;
                               }
                           }
                           if (exists($$olddata{$thiskey})) {
                               if (&Apache::lonnet::del('resourcedata',[$tkeynonrec,$tkeynonrec.'.type'],$tudom,$tuname) eq 'ok') {
                                   &log_parmset({$tkeynonrec=>''},1,$tuname,$tudom);
                                   unless ($recursive) {
                                       $r->print('<br />'.&mt('Deleted parameter for').' '.&Apache::loncommon::plainname($tuname,$tudom));
                                   }
                               } elsif (!$recursive) {
                                   $error = 1;
                               }
                         }                          }
                         $needsnewer = &parameter_releasecheck(undef,$valchk,$valmatch,$namematch,  
                                                               $needsrelease,$cmajor,$cminor);  
                     } else {                      } else {
                         undef($namematch);                          if (exists($$olddata{$thiskey})) {
                               if (&Apache::lonnet::del('resourcedata',[$tkey,$tkey.'.type'],$tudom,$tuname) eq 'ok') {
                                   &log_parmset({$tkey=>''},1,$tuname,$tudom);
                                   $r->print('<br />'.&mt('Deleted parameter for').' '.&Apache::loncommon::plainname($tuname,$tudom));
                               } else {
                                   $error = 1;
                               }
                           }
                       }
                       if ($error) { 
                           $r->print('<div class="LC_error">'.
                               &mt('Error deleting parameters').'</div>');
                       }
                       &Apache::lonnet::devalidateuserresdata($tuname,$tudom);
                   } else {
                       if ($altkey) {
                           if (exists($$olddata{$altkey})) {
                               unless (grep(/^\Q$altkey\E$/,@delrec)) {
                                   push(@deldata,($altkey,$altkey.'.type'));
                               }
                           }
                           if (exists($$olddata{$thiskey})) {
                               unless (grep(/^\Q$thiskey\E$/,@delnonrec)) {
                                   push(@deldata,($thiskey,$thiskey.'.type'));
                               }
                           }
                       } elsif (exists($$olddata{$thiskey})) {
                           push(@deldata,($thiskey,$thiskey.'.type'));
                     }                      }
                 }                  }
             }              }
             if ($needsnewer) {  
                 $r->print('<br />'.&oldversion_warning($name,$namematch,$data,  
                                                        $chostname,$cmajor,  
                                                        $cminor,$needsrelease));  
                 next;  
             }  
         }  
         if (defined($data) and $$olddata{$thiskey} ne $data) {  
             if ($tuname) {  
             if (&Apache::lonnet::put('resourcedata',{$tkey=>$data,  
                                  $tkey.'.type' => $typeof},  
                          $tudom,$tuname) eq 'ok') {  
                 &log_parmset({$tkey=>$data,$tkey.'.type' => $typeof},0,$tuname,$tudom);  
                 $r->print('<br />'.$text.' '.  
                       &Apache::loncommon::plainname($tuname,$tudom));  
             } else {  
                 $r->print('<div class="LC_error">'.  
                       &mt('Error saving parameters').'</div>');  
             }  
             &Apache::lonnet::devalidateuserresdata($tuname,$tudom);  
             } else {  
             $newdata{$thiskey}=$data;  
              $newdata{$thiskey.'.type'}=$typeof;  
                    }  
         }  
         } elsif ($cmd eq 'del') {  
         if ($tuname) {  
             if (&Apache::lonnet::del('resourcedata',[$tkey],$tudom,$tuname) eq 'ok') {  
                 &log_parmset({$tkey=>''},1,$tuname,$tudom);  
             $r->print('<br />'.&mt('Deleted parameter for').' '.&Apache::loncommon::plainname($tuname,$tudom));  
             } else {  
             $r->print('<div class="LC_error">'.  
                   &mt('Error deleting parameters').'</div>');  
             }  
             &Apache::lonnet::devalidateuserresdata($tuname,$tudom);  
         } else {  
             push (@deldata,$thiskey,$thiskey.'.type');  
         }  
         }          }
     }      }
     }  
 # Store all course level  # Store all course level
     my $delentries=$#deldata+1;      my $delentries=$#deldata+1;
       my @alldels;
       if (@delrec) {
           push(@alldels,@delrec);
       }
       if (@delnonrec) {
           push(@alldels,@delnonrec);
       }
       if (@deldata) {
           push(@alldels,@deldata);
       }
     my @newdatakeys=keys(%newdata);      my @newdatakeys=keys(%newdata);
     my $putentries=$#newdatakeys+1;      my $putentries=$#newdatakeys+1;
     if ($delentries) {      my ($delresult,$devalidate);
     if (&Apache::lonnet::del('resourcedata',\@deldata,$dom,$crs) eq 'ok') {      if (@alldels) {
         my %loghash=map { $_ => '' } @deldata;          if (&Apache::lonnet::del('resourcedata',\@alldels,$dom,$crs) eq 'ok') {
         &log_parmset(\%loghash,1);              my %loghash=map { $_ => '' } @alldels;
         $r->print('<h2>'.&mt('Deleted [quant,_1,parameter]',$delentries/2).'</h2>');              &log_parmset(\%loghash,1);
     } else {              if ($delentries) {
         $r->print('<div class="LC_error">'.                  $r->print('<h2>'.&mt('Deleted [quant,_1,parameter]',$delentries/2).'</h2>');
               &mt('Error deleting parameters').'</div>');              }
     }          } elsif ($delentries) {
     &Apache::lonnet::devalidatecourseresdata($crs,$dom);              $r->print('<div class="LC_error">'.
                   &mt('Error deleting parameters').'</div>');
           }
           $devalidate = 1; 
     }      }
     if ($putentries) {      if ($putentries) {
     if (&Apache::lonnet::put('resourcedata',\%newdata,$dom,$crs) eq 'ok') {          if (&Apache::lonnet::put('resourcedata',\%newdata,$dom,$crs) eq 'ok') {
                 &log_parmset(\%newdata,0);                      &log_parmset(\%newdata,0);
         $r->print('<h3>'.&mt('Saved [quant,_1,parameter]',$putentries/2).'</h3>');              $r->print('<h3>'.&mt('Saved [quant,_1,parameter]',$putentries/2).'</h3>');
     } else {          } else {
         $r->print('<div class="LC_error">'.              $r->print('<div class="LC_error">'.
               &mt('Error saving parameters').'</div>');                  &mt('Error saving parameters').'</div>');
           }
           $devalidate = 1; 
     }      }
     &Apache::lonnet::devalidatecourseresdata($crs,$dom);      if ($devalidate) {
           &Apache::lonnet::devalidatecourseresdata($crs,$dom);
     }      }
 }  }
   
   # Returns the username and domain from a key created in readdata from a resourcedata key.
   #
   # @param {string} $key - the key
   # @returns {Array}
 sub extractuser {  sub extractuser {
     my $key=shift;      my $key=shift;
     return ($key=~/^$env{'request.course.id'}.\[useropt\:($match_username)\:($match_domain)\]\./);      return ($key=~/^$env{'request.course.id'}.\[useropt\:($match_username)\:($match_domain)\]\./);
 }  }
   
   # Parses a parameter key and returns the components.
   #
   # @param {string} $key - 
   # @param {hash reference} $listdata - 
   # @return {Array} - (student, resource, part, parameter)
 sub parse_listdata_key {  sub parse_listdata_key {
     my ($key,$listdata) = @_;      my ($key,$listdata) = @_;
     # split into student/section affected, and      # split into student/section affected, and
Line 3408  sub parse_listdata_key { Line 4224  sub parse_listdata_key {
     ($key=~/^\Q$env{'request.course.id'}\E\.\[([^\.]+)\]\.(.+)$/);      ($key=~/^\Q$env{'request.course.id'}\E\.\[([^\.]+)\]\.(.+)$/);
     # if course wide student would be undefined      # if course wide student would be undefined
     if (!defined($student)) {      if (!defined($student)) {
     ($realm)=($key=~/^\Q$env{'request.course.id'}\E\.(.+)$/);          ($realm)=($key=~/^\Q$env{'request.course.id'}\E\.(.+)$/);
     }      }
     # strip off the .type if it's not the Question type parameter      # strip off the .type if it's not the Question type parameter
     if ($realm=~/\.type$/ && !exists($listdata->{$key.'.type'})) {      if ($realm=~/\.type$/ && !exists($listdata->{$key.'.type'})) {
     $realm=~s/\.type//;          $realm=~s/\.type//;
     }      }
     # split into resource+part and parameter name      # split into resource+part and parameter name
     my ($res,    $parm) = ($realm=~/^(.*)\.(.*)$/);      my ($res,    $parm) = ($realm=~/^(.*)\.(.*)$/);
Line 3420  sub parse_listdata_key { Line 4236  sub parse_listdata_key {
     return ($student,$res,$part,$parm);      return ($student,$res,$part,$parm);
 }  }
   
   # Prints HTML with forms for the given parameter data in overview mode (newoverview or overview).
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {hash reference} $resourcedata - parameter data returned by readdata
   # @param {hash reference} $listdata - data created in secgroup_lister, course id.[section id].part.name -> 1 or course id.[section id].part.name.type -> parameter type
   # @param {string} $sortorder - realmstudent|studentrealm
   # @param {string} $caller - name of the calling sub (overview|newoverview)
   # @param {hash reference} $classlist - from loncoursedata::get_classlist
   # @param {boolean} $readonly - true if editing not allowed
   # @returns{integer} - number of $listdata parameters processed
 sub listdata {  sub listdata {
     my ($r,$resourcedata,$listdata,$sortorder,$caller,$classlist)=@_;      my ($r,$resourcedata,$listdata,$sortorder,$caller,$classlist,$readonly)=@_;
           
 # Start list output  # Start list output
   
Line 3443  sub listdata { Line 4269  sub listdata {
         }          }
     }      }
   
     foreach my $thiskey (sort {      foreach my $key (sort {
     my ($astudent,$ares,$apart,$aparm) = &parse_listdata_key($a,$listdata);          my ($astudent,$ares,$apart,$aparm) = &parse_listdata_key($a,$listdata);
     my ($bstudent,$bres,$bpart,$bparm) = &parse_listdata_key($b,$listdata);          my ($bstudent,$bres,$bpart,$bparm) = &parse_listdata_key($b,$listdata);
   
     # get the numerical order for the param          # get the numerical order for the param
     $aparm=$keyorder{'parameter_0_'.$aparm};          $aparm=$keyorder{'parameter_0_'.$aparm};
     $bparm=$keyorder{'parameter_0_'.$bparm};          $bparm=$keyorder{'parameter_0_'.$bparm};
   
     my $result=0;          my $result=0;
   
     if ($sortorder eq 'realmstudent') {          if ($sortorder eq 'realmstudent') {
             if ($ares     ne $bres    ) {              if ($ares     ne $bres    ) {
         $result = ($ares     cmp $bres);                  $result = ($ares     cmp $bres);
             } elsif ($astudent ne $bstudent) {              } elsif ($astudent ne $bstudent) {
         $result = ($astudent cmp $bstudent);                  $result = ($astudent cmp $bstudent);
         } elsif ($apart    ne $bpart   ) {              } elsif ($apart    ne $bpart   ) {
         $result = ($apart    cmp $bpart);                  $result = ($apart    cmp $bpart);
         }              }
     } else {          } else {
         if      ($astudent ne $bstudent) {              if      ($astudent ne $bstudent) {
         $result = ($astudent cmp $bstudent);                  $result = ($astudent cmp $bstudent);
         } elsif ($ares     ne $bres    ) {              } elsif ($ares     ne $bres    ) {
         $result = ($ares     cmp $bres);                  $result = ($ares     cmp $bres);
         } elsif ($apart    ne $bpart   ) {              } elsif ($apart    ne $bpart   ) {
         $result = ($apart    cmp $bpart);                  $result = ($apart    cmp $bpart);
               }
         }          }
     }  
   
     if (!$result) {          if (!$result) {
             if (defined($aparm) && defined($bparm)) {              if (defined($aparm) && defined($bparm)) {
         $result = ($aparm <=> $bparm);                  $result = ($aparm <=> $bparm);
             } elsif (defined($aparm)) {              } elsif (defined($aparm)) {
         $result = -1;                  $result = -1;
             } elsif (defined($bparm)) {              } elsif (defined($bparm)) {
         $result = 1;                  $result = 1;
               }
         }          }
     }  
   
     $result;          $result;
     } keys(%{$listdata})) {          
       } keys(%{$listdata})) { # foreach my $key
     my $readonly;          my $thiskey = $key;
     if ($$listdata{$thiskey.'.type'}) {          if ($$listdata{$thiskey.'.type'}) {
         my $thistype=$$listdata{$thiskey.'.type'};              my $thistype=$$listdata{$thiskey.'.type'};
         if ($$resourcedata{$thiskey.'.type'}) {              if ($$resourcedata{$thiskey.'.type'}) {
             $thistype=$$resourcedata{$thiskey.'.type'};                  $thistype=$$resourcedata{$thiskey.'.type'};
         }              }
         my ($middle,$part,$name)=              my ($middle,$part,$name)=
         ($thiskey=~/^$env{'request.course.id'}\.(?:(.+)\.)*([\w\s]+)\.(\w+)$/);                  ($thiskey=~/^$env{'request.course.id'}\.(?:(.+)\.)*([\w\s\-]+)\.(\w+)$/);
         my $section=&mt('All Students');              my $section=&mt('All Students');
         if ($middle=~/^\[(.*)\]/) {              my $showval = $$resourcedata{$thiskey}; 
             my $issection=$1;              if ($middle=~/^\[(.*)\]/) {
             if ($issection=~/^useropt\:($match_username)\:($match_domain)/) {                  my $issection=$1;
                 my ($stuname,$studom) = ($1,$2);                  if ($issection=~/^useropt\:($match_username)\:($match_domain)/) {
                 if (($env{'request.course.sec'} ne '') && ($caller eq 'overview')) {                      my ($stuname,$studom) = ($1,$2);
                     if (ref($classlist) eq 'HASH') {                      if (($env{'request.course.sec'} ne '') && ($caller eq 'overview')) {
                         if (ref($classlist->{$stuname.':'.$studom}) eq 'ARRAY') {                          if (ref($classlist) eq 'HASH') {
                             next unless ($classlist->{$stuname.':'.$studom}->[$secidx] eq $env{'request.course.sec'});                               if (ref($classlist->{$stuname.':'.$studom}) eq 'ARRAY') {
                                   next unless ($classlist->{$stuname.':'.$studom}->[$secidx] eq $env{'request.course.sec'}); 
                               }
                         }                          }
                     }                      }
                 }                      $section=&mt('User').": ".&Apache::loncommon::plainname($stuname,$studom);
                 $section=&mt('User').": ".&Apache::loncommon::plainname($stuname,$studom);                  } else {
             } else {                      if (($env{'request.course.sec'} ne '') && ($caller eq 'overview')) {
                 if (($env{'request.course.sec'} ne '') && ($caller eq 'overview')) {                          if (exists($grouphash{$issection})) {
                     if (exists($grouphash{$issection})) {                              $section=&mt('Group').': '.$issection;
                         $section=&mt('Group').': '.$issection;                          } elsif ($issection eq $env{'request.course.sec'}) {
                     } elsif ($issection eq $env{'request.course.sec'}) {                              $section = &mt('Section').': '.$issection;
                         $section = &mt('Section').': '.$issection;                          } else {
                               next; 
                           }
                     } else {                      } else {
                         next;                           $section=&mt('Group/Section').': '.$issection;
                     }                      }
                 } else {                  }
                     $section=&mt('Group/Section').': '.$issection;                  $middle=~s/^\[(.*)\]//;
               } elsif (($env{'request.course.sec'} ne '') && ($caller eq 'overview')) {
                   $readonly = 1;
               }
               $middle=~s/\.+$//;
               $middle=~s/^\.+//;
               my $realm='<span class="LC_parm_scope_all">'.&mt('All Resources').'</span>';
               my ($is_map,$is_recursive,$mapurl,$maplevel);
               if ($caller eq 'overview') {
                   if ($middle=~/^(.+)\_\_\_\((all|rec)\)$/) {
                       $mapurl = $1;
                       $maplevel = $2;
                       $is_map = 1;
                   }
               } elsif ($caller eq 'newoverview') {
                   if ($middle=~/^(.+)\_\_\_\((all)\)$/) {
                       $mapurl = $1;
                       $maplevel = $2;
                       $is_map = 1;
                   }
               }
               if ($is_map) {
                   my $leveltitle = &mt('Folder/Map');
                   unless (($name eq 'hiddenresource') || ($name eq 'encrypturl')) {   
                       if ($caller eq 'newoverview') {
                           my $altkey = $thiskey;
                           $altkey =~ s/\Q___(all)\E/___(rec)/;
                           if ((exists($$resourcedata{$altkey})) & (!exists($$resourcedata{$thiskey}))) {
                               $is_recursive = 1;
                               if ($$resourcedata{$altkey.'.type'}) {
                                   $thistype=$$resourcedata{$altkey.'.type'};
                               }
                               $showval = $$resourcedata{$altkey};
                           }
                       } elsif (($caller eq 'overview') && ($maplevel eq 'rec')) {
                           $thiskey =~ s/\Q___(rec)\E/___(all)/;
                           $is_recursive = 1;
                       }
                   }
                   $realm='<span class="LC_parm_scope_folder">'.$leveltitle.': '.&Apache::lonnet::gettitle($mapurl).' <br /><span class="LC_parm_folder">('.$mapurl.')</span></span>';
               } elsif ($middle) {
                   my ($map,$id,$url)=&Apache::lonnet::decode_symb($middle);
                   $realm='<span class="LC_parm_scope_resource">'.&mt('Resource').
                       ': '.&Apache::lonnet::gettitle($middle).
                       ' <br /><span class="LC_parm_symb">('.$url.' in '.$map.' id: '.
                       $id.')</span></span>';
               }
               if ($sortorder eq 'realmstudent') {
                   if ($realm ne $oldrealm) {
                       $r->print(&tableend()."\n<hr /><h1>$realm</h1>");
                       $oldrealm=$realm;
                       $oldsection='';
                   }
                   if ($section ne $oldsection) {
                       $r->print(&tableend()."\n<h2>$section</h2>");
                       $oldsection=$section;
                       $oldpart='';
                   }
               } else {
                   if ($section ne $oldsection) {
                       $r->print(&tableend()."\n<hr /><h1>$section</h1>");
                       $oldsection=$section;
                       $oldrealm='';
                   }
                   if ($realm ne $oldrealm) {
                       $r->print(&tableend()."\n<h2>$realm</h2>");
                       $oldrealm=$realm;
                       $oldpart='';
                 }                  }
             }              }
             $middle=~s/^\[(.*)\]//;              if ($part ne $oldpart) {
         } elsif (($env{'request.course.sec'} ne '') && ($caller eq 'overview')) {                  $r->print(&tableend().
             $readonly = 1;                      "\n".'<span class="LC_parm_part">'.&mt('Part').": $part</span>");
         }                  $oldpart=$part;
         $middle=~s/\.+$//;  
         $middle=~s/^\.+//;  
         my $realm='<span class="LC_parm_scope_all">'.&mt('All Resources').'</span>';  
         if ($middle=~/^(.+)\_\_\_\((all|rec)\)$/) {  
             my $mapurl = $1;  
             my $maplevel = $2;  
             my $leveltitle = &mt('Folder/Map');  
             if ($maplevel eq 'rec') {  
                 $leveltitle = &mt('Recursive');  
             }              }
             $realm='<span class="LC_parm_scope_folder">'.$leveltitle.': '.&Apache::lonnet::gettitle($mapurl).' <br /><span class="LC_parm_folder">('.$mapurl.')</span></span>';      #
         } elsif ($middle) {      # Ready to print
         my ($map,$id,$url)=&Apache::lonnet::decode_symb($middle);      #
         $realm='<span class="LC_parm_scope_resource">'.&mt('Resource').': '.&Apache::lonnet::gettitle($middle).' <br /><span class="LC_parm_symb">('.$url.' in '.$map.' id: '.$id.')</span></span>';  
         }  
         if ($sortorder eq 'realmstudent') {  
         if ($realm ne $oldrealm) {  
             $r->print(&tableend()."\n<hr /><h1>$realm</h1>");  
             $oldrealm=$realm;  
             $oldsection='';  
         }  
         if ($section ne $oldsection) {  
             $r->print(&tableend()."\n<h2>$section</h2>");  
             $oldsection=$section;  
             $oldpart='';  
         }  
         } else {  
         if ($section ne $oldsection) {  
             $r->print(&tableend()."\n<hr /><h1>$section</h1>");  
             $oldsection=$section;  
             $oldrealm='';  
         }  
         if ($realm ne $oldrealm) {  
             $r->print(&tableend()."\n<h2>$realm</h2>");  
             $oldrealm=$realm;  
             $oldpart='';  
         }  
         }  
         if ($part ne $oldpart) {  
         $r->print(&tableend().  
               "\n".'<span class="LC_parm_part">'.&mt('Part').": $part</span>");  
         $oldpart=$part;  
         }  
 #  
 # Ready to print  
 #  
             my $parmitem = &standard_parameter_names($name);              my $parmitem = &standard_parameter_names($name);
         $r->print(&tablestart($readonly).              $r->print(&tablestart($readonly,$is_map).
               &Apache::loncommon::start_data_table_row().                  &Apache::loncommon::start_data_table_row().
               '<td><b>'.&mt($parmitem).                  '<td><b>'.&mt($parmitem).
               '</b></td>');                  '</b></td>');
         unless ($readonly) {              unless ($readonly) {
             $r->print('<td><input type="checkbox" name="del_'.                  $r->print('<td><input type="checkbox" name="del_'.
                       $thiskey.'" /></td>');                          $thiskey.'" /></td>');
         }              }
         $r->print('<td>');              $r->print('<td>');
         $foundkeys++;              $foundkeys++;
         if (&isdateparm($thistype)) {              if (&isdateparm($thistype)) {
             my $jskey='key_'.$pointer;                  my $jskey='key_'.$pointer;
             my $state;                  my $state;
             $pointer++;                  $pointer++;
             if ($readonly) {                  if ($readonly) {
                 $state = 'disabled';                      $state = 'disabled';
             }                  }
             $r->print(  
                 &Apache::lonhtmlcommon::date_setter('parmform',  
                                                     $jskey,  
                                                     $$resourcedata{$thiskey},  
                                                     '',1,$state));  
             unless  ($readonly) {  
                 $r->print(                  $r->print(
 '<input type="hidden" name="datepointer_'.$thiskey.'" value="'.$jskey.'" />'.                      &Apache::lonhtmlcommon::date_setter('parmform',
 (($$resourcedata{$thiskey}!=0)?'<span class="LC_nobreak"><a href="/adm/parmset?&action=dateshift1&timebase='.$$resourcedata{$thiskey}.'">'.                                                          $jskey,
 &mt('Shift all dates based on this date').'</a></span>':'').                                                          $showval,
 &date_sanity_info($$resourcedata{$thiskey})                                                          '',1,$state));
                 );                  unless  ($readonly) {
                       $r->print(
       '<input type="hidden" name="datepointer_'.$thiskey.'" value="'.$jskey.'" />'.
       (($showval!=0)?'<span class="LC_nobreak"><a href="/adm/parmset?&action=dateshift1&timebase='.$showval.'">'.
       &mt('Shift all dates based on this date').'</a></span>':'').
       &date_sanity_info($showval)
                       );
                   }
               } elsif ($thistype eq 'date_interval') {
                   $r->print(&date_interval_selector($thiskey,$name,
                             $showval,$readonly));
               } elsif ($thistype =~ m/^string/) {
                   $r->print(&string_selector($thistype,$thiskey,
                             $showval,$name,$readonly));
               } else {
                   $r->print(&default_selector($thiskey,$showval,$readonly));
             }              }
         } elsif ($thistype eq 'date_interval') {              unless ($readonly) {
             $r->print(&date_interval_selector($thiskey,$name,                  $r->print('<input type="hidden" name="typeof_'.$thiskey.'" value="'.
                       $$resourcedata{$thiskey},$readonly));                          $thistype.'" />');
         } elsif ($thistype =~ m/^string/) {              }
             $r->print(&string_selector($thistype,$thiskey,              $r->print('</td>');
                       $$resourcedata{$thiskey},$name,$readonly));              if ($is_map) {
         } else {                  if (($name eq 'encrypturl') || ($name eq 'hiddenresource')) {
             $r->print(&default_selector($thiskey,$$resourcedata{$thiskey},$readonly));                      $r->print('<td><table><tr><td>'.&mt('Yes').'</td></tr></table></td>');
         }                  } else {
         unless ($readonly) {                      my ($disabled,$recon,$recoff);
             $r->print('<input type="hidden" name="typeof_'.$thiskey.'" value="'.                      if ($readonly) {
                       $thistype.'" />');                          $disabled = ' disabled="disabled"';
                       }
                       if ($is_recursive) {
                           $recon = ' checked="checked"';
                       } else {
                           $recoff = ' checked="checked"';
                       }
                       $r->print('<td><table><tr><td><label><input type="radio" name="rec_'.$thiskey.'" value="1"'.$recon.$disabled.' />'.&mt('Yes').'</label>'.
                                 '</td><td><label><input type="radio" name="rec_'.$thiskey.'" value="0"'.$recoff.$disabled.' />'.&mt('No').'</label></td></tr></table></td>');
                   }
               }
               $r->print(&Apache::loncommon::end_data_table_row());
         }          }
         $r->print('</td>'.&Apache::loncommon::end_data_table_row());  
     }  
     }      }
     return $foundkeys;      return $foundkeys;
 }  }
   
   # Returns a string representing the interval, directly using form data matching the given key.
   # The returned string may also include information related to proctored exams.
   # Format: seconds['_done'[':'done button title':']['_proctor'['_'proctor key]]]
   #
   # @param {string} $key - suffix for form fields related to the interval
   # @returns {string}
 sub get_date_interval_from_form {  sub get_date_interval_from_form {
     my ($key) = @_;      my ($key) = @_;
     my $seconds = 0;      my $seconds = 0;
Line 3625  sub get_date_interval_from_form { Line 4504  sub get_date_interval_from_form {
                ['hours', 3600],                 ['hours', 3600],
                ['minutes', 60],                 ['minutes', 60],
                ['seconds',  1]) {                 ['seconds',  1]) {
     my ($name, $factor) = @{ $which };          my ($name, $factor) = @{ $which };
     if (defined($env{'form.'.$name.'_'.$key})) {          if (defined($env{'form.'.$name.'_'.$key})) {
         $seconds += $env{'form.'.$name.'_'.$key} * $factor;              $seconds += $env{'form.'.$name.'_'.$key} * $factor;
     }          }
     }      }
     if (($key =~ /\.interval$/) && (($env{'form.done_'.$key} eq '_done') || ($env{'form.done_'.$key} eq '_done_proctor'))) {      if (($key =~ /\.interval$/) &&
         $seconds .= $env{'form.done_'.$key};              (($env{'form.done_'.$key} eq '_done') || ($env{'form.done_'.$key} eq '_done_proctor'))) {
         if ($env{'form.done_'.$key.'_proctorkey'}) {          if ($env{'form.done_'.$key.'_buttontext'}) {
               $env{'form.done_'.$key.'_buttontext'} =~ s/\://g;
               $seconds .= '_done:'.$env{'form.done_'.$key.'_buttontext'}.':';
               if ($env{'form.done_'.$key} eq '_done_proctor') {
                   $seconds .= '_proctor';
               }
           } else {
               $seconds .= $env{'form.done_'.$key}; 
           }
           if (($env{'form.done_'.$key} eq '_done_proctor') && 
                   ($env{'form.done_'.$key.'_proctorkey'})) {
             $seconds .= '_'.$env{'form.done_'.$key.'_proctorkey'};              $seconds .= '_'.$env{'form.done_'.$key.'_proctorkey'};
         }          }
     }      }
Line 3640  sub get_date_interval_from_form { Line 4529  sub get_date_interval_from_form {
 }  }
   
   
   # Returns HTML to enter a text value for a parameter.
   #
   # @param {string} $thiskey - parameter key
   # @param {string} $showval - the current value
   # @param {boolean} $readonly - true if the field should not be made editable
   # @returns {string}
 sub default_selector {  sub default_selector {
     my ($thiskey, $showval, $readonly) = @_;      my ($thiskey, $showval, $readonly) = @_;
     my $disabled;      my $disabled;
Line 3649  sub default_selector { Line 4544  sub default_selector {
     return '<input type="text" name="set_'.$thiskey.'" value="'.$showval.'"'.$disabled.' />';      return '<input type="text" name="set_'.$thiskey.'" value="'.$showval.'"'.$disabled.' />';
 }  }
   
   # Returns HTML to enter allow/deny rules related to IP addresses.
   #
   # @param {string} $thiskey - parameter key
   # @param {string} $showval - the current value
   # @param {boolean} $readonly - true if the fields should not be made editable
   # @returns {string}
 sub string_ip_selector {  sub string_ip_selector {
     my ($thiskey, $showval, $readonly) = @_;      my ($thiskey, $showval, $readonly) = @_;
     my %access = (      my %access = (
Line 3677  sub string_ip_selector { Line 4578  sub string_ip_selector {
         @{$access{'deny'}} = ('');          @{$access{'deny'}} = ('');
     }      }
     my ($disabled,$addmore);      my ($disabled,$addmore);
     if ($disabled) {      if ($readonly) {
         $disabled=' disabled="disabled"';          $disabled=' disabled="disabled"';
     } else {      } else {
         $addmore = "\n".'<button class="LC_add_ipacc_button">'.&mt('Add more').'</button>';          $addmore = "\n".'<button class="LC_add_ipacc_button">'.&mt('Add more').'</button>';
Line 3709  sub string_ip_selector { Line 4610  sub string_ip_selector {
     return $output;      return $output;
 }  }
   
 {  
   { # block using some constants related to parameter types (overview mode)
   
 my %strings =  my %strings =
     (      (
      'string_yesno'       'string_yesno'
              => [[ 'yes', 'Yes' ],               => [[ 'yes', 'Yes' ],
          [ 'no', 'No' ]],                   [ 'no', 'No' ]],
      'string_problemstatus'       'string_problemstatus'
              => [[ 'yes', 'Yes' ],               => [[ 'yes', 'Yes' ],
          [ 'answer', 'Yes, and show correct answer if they exceed the maximum number of tries.' ],           [ 'answer', 'Yes, and show correct answer if they exceed the maximum number of tries.' ],
Line 3760  my %stringtypes = ( Line 4663  my %stringtypes = (
                     acc          => 'string_ip',                      acc          => 'string_ip',
                   );                    );
   
   # Returns the possible values and titles for a given string type, or undef if there are none.
   # Used by courseprefs.
   #
   # @param {string} $string_type - a parameter type for strings
   # @returns {array reference} - 2D array, containing values and English titles
 sub standard_string_options {  sub standard_string_options {
     my ($string_type) = @_;      my ($string_type) = @_;
     if (ref($strings{$string_type}) eq 'ARRAY') {      if (ref($strings{$string_type}) eq 'ARRAY') {
Line 3768  sub standard_string_options { Line 4676  sub standard_string_options {
     return;      return;
 }  }
   
   # Returns regular expressions to match kinds of string types, or undef if there are none.
   #
   # @param {string} $string_type - a parameter type for strings
   # @returns {array reference}  - 2D array, containing regular expression names and regular expressions
 sub standard_string_matches {  sub standard_string_matches {
     my ($string_type) = @_;      my ($string_type) = @_;
     if (ref($stringmatches{$string_type}) eq 'ARRAY') {      if (ref($stringmatches{$string_type}) eq 'ARRAY') {
Line 3776  sub standard_string_matches { Line 4688  sub standard_string_matches {
     return;      return;
 }  }
   
   # Returns a parameter type for a given parameter with a string type, or undef if not known.
   #
   # @param {string} $name - parameter name
   # @returns {string}
 sub get_stringtype {  sub get_stringtype {
     my ($name) = @_;      my ($name) = @_;
     if (exists($stringtypes{$name})) {      if (exists($stringtypes{$name})) {
Line 3784  sub get_stringtype { Line 4700  sub get_stringtype {
     return;      return;
 }  }
   
   # Returns HTML to edit a string parameter.
   #
   # @param {string} $thistype - parameter type
   # @param {string} $thiskey - parameter key
   # @param {string} $showval - parameter current value
   # @param {string} $name - parameter name
   # @param {boolean} $readonly - true if the values should not be made editable
   # @returns {string}
 sub string_selector {  sub string_selector {
     my ($thistype, $thiskey, $showval, $name, $readonly) = @_;      my ($thistype, $thiskey, $showval, $name, $readonly) = @_;
   
Line 3793  sub string_selector { Line 4717  sub string_selector {
   
     my %skiptype;      my %skiptype;
     if (($thistype eq 'string_questiontype') ||       if (($thistype eq 'string_questiontype') || 
         ($thistype eq 'string_lenient') ||              ($thistype eq 'string_lenient') ||
         ($thistype eq 'string_discussvote') ||              ($thistype eq 'string_discussvote') ||
         ($thistype eq 'string_ip') ||              ($thistype eq 'string_ip') ||
         ($name eq 'retrypartial')) {              ($name eq 'retrypartial')) {
         my ($got_chostname,$chostname,$cmajor,$cminor);           my ($got_chostname,$chostname,$cmajor,$cminor); 
         foreach my $possibilities (@{ $strings{$thistype} }) {          foreach my $possibilities (@{ $strings{$thistype} }) {
             next unless (ref($possibilities) eq 'ARRAY');              next unless (ref($possibilities) eq 'ARRAY');
Line 3941  my %intervals = Line 4865  my %intervals =
   
 my %intervalmatches = (  my %intervalmatches = (
          'date_interval'           'date_interval'
               => [['done','\d+_done$'],                => [['done','\d+_done(|\:[^\:]+\:)$'],
                   ['done_proctor','\d+_done_proctor_']],                    ['done_proctor','\d+_done(|\:[^\:]+\:)_proctor_']],
     );      );
   
 my %intervaltypes = (  my %intervaltypes = (
                       interval => 'date_interval',                        interval => 'date_interval',
     );      );
   
   # Returns regular expressions to match kinds of interval type, or undef if there are none.
   #
   # @param {string} $interval_type - a parameter type for intervals
   # @returns {array reference}  - 2D array, containing regular expression names and regular expressions
 sub standard_interval_matches {  sub standard_interval_matches {
     my ($interval_type) = @_;      my ($interval_type) = @_;
     if (ref($intervalmatches{$interval_type}) eq 'ARRAY') {      if (ref($intervalmatches{$interval_type}) eq 'ARRAY') {
Line 3957  sub standard_interval_matches { Line 4885  sub standard_interval_matches {
     return;      return;
 }  }
   
   # Returns a parameter type for a given parameter with an interval type, or undef if not known.
   #
   # @param {string} $name - parameter name
   # @returns {string}
 sub get_intervaltype {  sub get_intervaltype {
     my ($name) = @_;      my ($name) = @_;
     if (exists($intervaltypes{$name})) {      if (exists($intervaltypes{$name})) {
Line 3965  sub get_intervaltype { Line 4897  sub get_intervaltype {
     return;      return;
 }  }
   
   # Returns the possible values and titles for a given interval type, or undef if there are none.
   # Used by courseprefs.
   #
   # @param {string} $interval_type - a parameter type for intervals
   # @returns {array reference} - 2D array, containing values and English titles
 sub standard_interval_options {  sub standard_interval_options {
     my ($interval_type) = @_;      my ($interval_type) = @_;
     if (ref($intervals{$interval_type}) eq 'ARRAY') {      if (ref($intervals{$interval_type}) eq 'ARRAY') {
Line 3973  sub standard_interval_options { Line 4910  sub standard_interval_options {
     return;      return;
 }  }
   
   # Returns HTML to edit a date interval parameter.
   #
   # @param {string} $thiskey - parameter key
   # @param {string} $name - parameter name
   # @param {string} $showval - parameter current value
   # @param {boolean} $readonly - true if the values should not be made editable
   # @returns {string}
 sub date_interval_selector {  sub date_interval_selector {
     my ($thiskey, $name, $showval, $readonly) = @_;      my ($thiskey, $name, $showval, $readonly) = @_;
     my ($result,%skipval);      my ($result,%skipval);
Line 4018  sub date_interval_selector { Line 4962  sub date_interval_selector {
                ['hours', 3600, 23],                 ['hours', 3600, 23],
                ['minutes', 60, 59],                 ['minutes', 60, 59],
                ['seconds',  1, 59]) {                 ['seconds',  1, 59]) {
     my ($name, $factor, $max) = @{ $which };          my ($name, $factor, $max) = @{ $which };
     my $amount = int($showval/$factor);          my $amount = int($showval/$factor);
     $showval  %= $factor;          $showval  %= $factor;
     my %select = ((map {$_ => $_} (0..$max)),          my %select = ((map {$_ => $_} (0..$max)),
               'select_form_order' => [0..$max]);                  'select_form_order' => [0..$max]);
     $result .= &Apache::loncommon::select_form($amount,$name.'_'.$thiskey,          $result .= &Apache::loncommon::select_form($amount,$name.'_'.$thiskey,
                            \%select,'',$readonly);                              \%select,'',$readonly);
     $result .= ' '.&mt($name);          $result .= ' '.&mt($name);
     }      }
     if ($name eq 'interval') {      if ($name eq 'interval') {
         unless ($skipval{'done'}) {          unless ($skipval{'done'}) {
Line 4033  sub date_interval_selector { Line 4977  sub date_interval_selector {
             my $checkedproc = '';              my $checkedproc = '';
             my $currproctorkey = '';              my $currproctorkey = '';
             my $currprocdisplay = 'hidden';              my $currprocdisplay = 'hidden';
               my $currdonetext = &mt('Done');
             my $checkedoff = ' checked="checked"';              my $checkedoff = ' checked="checked"';
             if ($currval =~ /^(\d+)_done$/) {              if ($currval =~ /^(?:\d+)_done$/) {
                   $checkedon = ' checked="checked"';
                   $checkedoff = '';
               } elsif ($currval =~ /^(?:\d+)_done\:([^\:]+)\:$/) {
                   $currdonetext = $1;
                 $checkedon = ' checked="checked"';                  $checkedon = ' checked="checked"';
                 $checkedoff = '';                  $checkedoff = '';
             } elsif ($currval =~ /^(?:\d+)_done_proctor_(.+)$/) {              } elsif ($currval =~ /^(?:\d+)_done_proctor_(.+)$/) {
Line 4042  sub date_interval_selector { Line 4991  sub date_interval_selector {
                 $checkedproc = ' checked="checked"';                  $checkedproc = ' checked="checked"';
                 $checkedoff = '';                  $checkedoff = '';
                 $currprocdisplay = 'text';                  $currprocdisplay = 'text';
               } elsif ($currval =~ /^(?:\d+)_done\:([^\:]+)\:_proctor_(.+)$/) {
                   $currdonetext = $1;
                   $currproctorkey = $2;
                   $checkedproc = ' checked="checked"';
                   $checkedoff = '';
                   $currprocdisplay = 'text';
             }              }
             my $onclick = ' onclick="toggleSecret(this.form,'."'done_','$thiskey'".');"';              my $onclick = ' onclick="toggleSecret(this.form,'."'done_','$thiskey'".');"';
               my $disabled;
               if ($readonly) {
                   $disabled = ' disabled="disabled"';
               }
             $result .= '<br /><span class="LC_nobreak">'.&mt('Include "done" button').              $result .= '<br /><span class="LC_nobreak">'.&mt('Include "done" button').
                        '<label><input type="radio" value="" name="done_'.$thiskey.'"'.$checkedoff.$onclick.' />'.                         '<label><input type="radio" value="" name="done_'.$thiskey.'"'.$checkedoff.$onclick.$disabled.' />'.
                        &mt('No').'</label>'.('&nbsp;'x2).                         &mt('No').'</label>'.('&nbsp;'x2).
                        '<label><input type="radio" value="_done" name="done_'.$thiskey.'"'.$checkedon.$onclick.' />'.                         '<label><input type="radio" value="_done" name="done_'.$thiskey.'"'.$checkedon.$onclick.$disabled.' />'.
                        &mt('Yes').'</label>'.('&nbsp;'x2).                         &mt('Yes').'</label>'.('&nbsp;'x2).
                        '<label><input type="radio" value="_done_proctor" name="done_'.$thiskey.'"'.$checkedproc.$onclick.' />'.                         '<label><input type="radio" value="_done_proctor" name="done_'.$thiskey.'"'.$checkedproc.$onclick.$disabled.' />'.
                        &mt('Yes, with proctor key').'</label>'.                         &mt('Yes, with proctor key').'</label>'.
                        '<input type="'.$currprocdisplay.'" id="done_'.$thiskey.'_proctorkey" '.                         '<input type="'.$currprocdisplay.'" id="done_'.$thiskey.'_proctorkey" '.
                        'name="done_'.$thiskey.'_proctorkey" value="'.$currproctorkey.'" /></span>';                         'name="done_'.$thiskey.'_proctorkey" value="'.&HTML::Entities::encode($currproctorkey,'"<>&').'"'.$disabled.' /></span><br />'.
                          '<span class="LC_nobreak">'.&mt('Button text').': '.
                          '<input type="text" name="done_'.$thiskey.'_buttontext" value="'.&HTML::Entities::encode($currdonetext,'"<>&').'"'.$disabled.' /></span>';
         }          }
     }      }
     unless ($readonly) {      unless ($readonly) {
Line 4061  sub date_interval_selector { Line 5022  sub date_interval_selector {
     return $result;      return $result;
 }  }
   
   # Returns HTML with a warning if a parameter requires a more recent version of LON-CAPA.
   #
   # @param {string} $name - parameter name
   # @param {string} $namematch - parameter level name (recognized: resourcelevel|maplevel|maplevelrecurse|courselevel)
   # @param {string} $value - parameter value
   # @param {string} $chostname - course server name
   # @param {integer} $cmajor - major version number
   # @param {integer} $cminor - minor version number
   # @param {string} $needsrelease - release version needed (major.minor)
   # @returns {string}
 sub oldversion_warning {  sub oldversion_warning {
     my ($name,$namematch,$value,$chostname,$cmajor,$cminor,$needsrelease) = @_;      my ($name,$namematch,$value,$chostname,$cmajor,$cminor,$needsrelease) = @_;
     my $standard_name = &standard_parameter_names($name);      my $standard_name = &standard_parameter_names($name);
Line 4133  sub oldversion_warning { Line 5104  sub oldversion_warning {
        '</p>';         '</p>';
 }  }
   
 }  } # end of block using some constants related to parameter types
   
 #  
 # Shift all start and end dates by $shift  
 #  
   
   
   # Shifts all start and end dates in the current course by $shift.
   #
   # @param {integer} $shift - time to shift, in seconds
   # @returns {string} - error name or 'ok'
 sub dateshift {  sub dateshift {
     my ($shift)=@_;      my ($shift)=@_;
     my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
Line 4170  sub dateshift { Line 5143  sub dateshift {
     return $reply;      return $reply;
 }  }
   
   # Overview mode UI to edit course parameters.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub newoverview {  sub newoverview {
     my ($r) = @_;      my ($r,$parm_permission) = @_;
   
     my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
     my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};      my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};
     my $crstype =  $env{'course.'.$env{'request.course.id'}.'.type'};      my $crstype =  $env{'course.'.$env{'request.course.id'}.'.type'};
       my $readonly = 1;
       if ($parm_permission->{'edit'}) {
           undef($readonly);
       }
     &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=setoverview',      &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=setoverview',
         text=>"Overview Mode"});          text=>"Overview Mode"});
   
Line 4334  ENDOVER Line 5314  ENDOVER
   
 # List data  # List data
   
         &listdata($r,$resourcedata,$listdata,$sortorder,'newoverview');          &listdata($r,$resourcedata,$listdata,$sortorder,'newoverview',undef,$readonly);
       }
       $r->print(&tableend());
       unless ($readonly) {
           $r->print( ((($env{'form.store'}) || ($env{'form.dis'}))?'<p><input type="submit" name="store" value="'.&mt('Save').'" /></p>':'') );
     }      }
     $r->print(&tableend().      $r->print('</form>');
          ((($env{'form.store'}) || ($env{'form.dis'}))?'<p><input type="submit" name="store" value="'.&mt('Save').'" /></p>':'').  
           '</form>');  
     &endSettingsScreen($r);      &endSettingsScreen($r);
     $r->print(&Apache::loncommon::end_page());      $r->print(&Apache::loncommon::end_page());
 }  }
   
   # Fills $listdata with parameter information.
   # Keys use the format course id.[section id].part.name and course id.[section id].part.name.type.
   # The non-type value is always 1.
   #
   # @param {string} $cat - parameter name
   # @param {string} $pschp - selected map pc, or 'all'
   # @param {string} $parmlev - selected level value (full|map|general), or ''
   # @param {hash reference} $listdata - the parameter data that will be modified
   # @param {array reference} $psprt - selected parts
   # @param {array reference} $selections - selected sections
   # @param {hash reference} $defkeytype - hash parameter name -> parameter type
   # @param {hash reference} $allmaps - hash map pc -> map src
   # @param {array reference} $ids - resource and map ids
   # @param {hash reference} $symbp - hash map pc or resource/map id -> map src.'___(all)' or resource symb
 sub secgroup_lister {  sub secgroup_lister {
     my ($cat,$pschp,$parmlev,$listdata,$psprt,$selections,$defkeytype,$allmaps,$ids,$symbp) = @_;      my ($cat,$pschp,$parmlev,$listdata,$psprt,$selections,$defkeytype,$allmaps,$ids,$symbp) = @_;
     foreach my $item (@{$selections}) {      foreach my $item (@{$selections}) {
Line 4363  sub secgroup_lister { Line 5359  sub secgroup_lister {
                     my $newparmkey=$rootparmkey.'.'.$$allmaps{$mapid}.'___(all).'.$part.'.'.$cat;                      my $newparmkey=$rootparmkey.'.'.$$allmaps{$mapid}.'___(all).'.$part.'.'.$cat;
                     $$listdata{$newparmkey}=1;                      $$listdata{$newparmkey}=1;
                     $$listdata{$newparmkey.'.type'}=$$defkeytype{$cat};                      $$listdata{$newparmkey.'.type'}=$$defkeytype{$cat};
                     $newparmkey=$rootparmkey.'.'.$$allmaps{$mapid}.'___(rec).'.$part.'.'.$cat;  
                     $$listdata{$newparmkey}=1;  
                     $$listdata{$newparmkey.'.type'}=$$defkeytype{$cat};  
                 }                  }
             } else {              } else {
 # resource-level parameter  # resource-level parameter
Line 4381  sub secgroup_lister { Line 5374  sub secgroup_lister {
     }      }
 }  }
   
   # UI to edit parameter settings starting with a list of all existing parameters.
   # (called by setoverview action)
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub overview {  sub overview {
     my ($r) = @_;      my ($r,$parm_permission) = @_;
     my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
     my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};      my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};
     my $crstype = $env{'course.'.$env{'request.course.id'}.'.type'};      my $crstype = $env{'course.'.$env{'request.course.id'}.'.type'};
       my $readonly = 1;
       if ($parm_permission->{'edit'}) {
           undef($readonly);
       }
     my $js = '<script type="text/javascript">'."\n".      my $js = '<script type="text/javascript">'."\n".
              '// <![CDATA['."\n".               '// <![CDATA['."\n".
              &toggleparmtextbox_js()."\n".               &toggleparmtextbox_js()."\n".
Line 4408  sub overview { Line 5409  sub overview {
   
 # Store modified  # Store modified
   
     &storedata($r,$crs,$dom);      unless ($readonly) {
           &storedata($r,$crs,$dom);
       }
   
 # Read modified data  # Read modified data
   
Line 4419  sub overview { Line 5422  sub overview {
     unless ($sortorder) { $sortorder='realmstudent'; }      unless ($sortorder) { $sortorder='realmstudent'; }
     &sortmenu($r,$sortorder);      &sortmenu($r,$sortorder);
   
       my $submitbutton = '<input type="submit" value="'.&mt('Save').'" />';
   
       if ($readonly) {
           $r->print('<p>'.$submitbutton.'</p>');
       }
   
 # List data  # List data
   
     my $foundkeys=&listdata($r,$resourcedata,$resourcedata,$sortorder,'overview',$classlist);      my $foundkeys=&listdata($r,$resourcedata,$resourcedata,$sortorder,'overview',$classlist,$readonly);
     $r->print(&tableend().'<p>'.      $r->print(&tableend().'<p>');
     ($foundkeys?'<input type="submit" value="'.&mt('Save').'" />':'<span class="LC_info">'.&mt('There are no parameters.').'</span>').'</p></form>'.      if ($foundkeys) {
           &Apache::loncommon::end_page());          unless ($readonly) {
               $r->print('<p>'.$submitbutton.'</p>');
           }
       } else {
           $r->print('<p class="LC_info">'.&mt('There are no parameters.').'</p>');
       }
       $r->print('</form>'.&Apache::loncommon::end_page());
 }  }
   
   # Unused sub.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub clean_parameters {  sub clean_parameters {
     my ($r) = @_;      my ($r) = @_;
     my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
Line 4462  ENDOVER Line 5480  ENDOVER
           '<th>'.&mt('Parameter').'</th>'.            '<th>'.&mt('Parameter').'</th>'.
           '</tr>');            '</tr>');
     foreach my $thiskey (sort(keys(%{$resourcedata}))) {      foreach my $thiskey (sort(keys(%{$resourcedata}))) {
     next if (!exists($resourcedata->{$thiskey.'.type'})          next if (!exists($resourcedata->{$thiskey.'.type'})
          && $thiskey=~/\.type$/);              && $thiskey=~/\.type$/);
     my %data = &parse_key($thiskey);          my %data = &parse_key($thiskey);
     if (1) { #exists($data{'realm_exists'})          if (1) { #exists($data{'realm_exists'})
         #&& !$data{'realm_exists'}) {              #&& !$data{'realm_exists'}) {
         $r->print(&Apache::loncommon::start_data_table_row().              $r->print(&Apache::loncommon::start_data_table_row().
               '<tr>'.                  '<tr>'.
               '<td><input type="checkbox" name="del_'.$thiskey.'" /></td>'              );                  '<td><input type="checkbox" name="del_'.$thiskey.'" /></td>'              );
   
         $r->print('<td>');              $r->print('<td>');
         my $display_value = $resourcedata->{$thiskey};              my $display_value = $resourcedata->{$thiskey};
         if (&isdateparm($resourcedata->{$thiskey.'.type'})) {              if (&isdateparm($resourcedata->{$thiskey.'.type'})) {
         $display_value =              $display_value =
             &Apache::lonlocal::locallocaltime($display_value);                  &Apache::lonlocal::locallocaltime($display_value);
         }              }
             my $parmitem = &standard_parameter_names($data{'parameter_name'});              my $parmitem = &standard_parameter_names($data{'parameter_name'});
             $parmitem = &mt($parmitem);              $parmitem = &mt($parmitem);
         $r->print(&mt('Parameter: "[_1]" with value: "[_2]"',              $r->print(&mt('Parameter: "[_1]" with value: "[_2]"',
               $parmitem,$resourcedata->{$thiskey}));                  $parmitem,$resourcedata->{$thiskey}));
         $r->print('<br />');              $r->print('<br />');
         if ($data{'scope_type'} eq 'all') {              if ($data{'scope_type'} eq 'all') {
         $r->print(&mt('All users'));                  $r->print(&mt('All users'));
         } elsif ($data{'scope_type'} eq 'user') {              } elsif ($data{'scope_type'} eq 'user') {
         $r->print(&mt('User: [_1]',join(':',@{$data{'scope'}})));                  $r->print(&mt('User: [_1]',join(':',@{$data{'scope'}})));
         } elsif ($data{'scope_type'} eq 'section') {              } elsif ($data{'scope_type'} eq 'secgroup') {
         $r->print(&mt('Section: [_1]',$data{'scope'}));                  $r->print(&mt('Group/Section: [_1]',$data{'scope'}));
         } elsif ($data{'scope_type'} eq 'group') {              }
         $r->print(&mt('Group: [_1]',$data{'scope'}));              $r->print('<br />');
         }              if ($data{'realm_type'} eq 'all') {
         $r->print('<br />');                  $r->print(&mt('All Resources'));
         if ($data{'realm_type'} eq 'all') {              } elsif ($data{'realm_type'} eq 'folder') {
         $r->print(&mt('All Resources'));                  $r->print(&mt('Folder: [_1]'),$data{'realm'});
         } elsif ($data{'realm_type'} eq 'folder') {              } elsif ($data{'realm_type'} eq 'symb') {
         $r->print(&mt('Folder: [_1]'),$data{'realm'});              my ($map,$resid,$url) =
         } elsif ($data{'realm_type'} eq 'symb') {                  &Apache::lonnet::decode_symb($data{'realm'});
         my ($map,$resid,$url) =              $r->print(&mt('Resource: [_1]with ID: [_2]in folder [_3]',
             &Apache::lonnet::decode_symb($data{'realm'});                          $url.' <br />&nbsp;&nbsp;&nbsp;',
         $r->print(&mt('Resource: [_1]with ID: [_2]in folder [_3]',                          $resid.' <br />&nbsp;&nbsp;&nbsp;',$map));
                       $url.' <br />&nbsp;&nbsp;&nbsp;',              }
                       $resid.' <br />&nbsp;&nbsp;&nbsp;',$map));              $r->print(' <br />&nbsp;&nbsp;&nbsp;'.&mt('Part: [_1]',$data{'parameter_part'}));
         }              $r->print('</td></tr>');
         $r->print(' <br />&nbsp;&nbsp;&nbsp;'.&mt('Part: [_1]',$data{'parameter_part'}));  
         $r->print('</td></tr>');  
   
     }          }
     }      }
     $r->print(&Apache::loncommon::end_data_table().'<p>'.      $r->print(&Apache::loncommon::end_data_table().'<p>'.
           '<input type="submit" value="'.&mt('Delete Selected').'" />'.            '<input type="submit" value="'.&mt('Delete Selected').'" />'.
Line 4515  ENDOVER Line 5531  ENDOVER
     $r->print(&Apache::loncommon::end_page());      $r->print(&Apache::loncommon::end_page());
 }  }
   
   # UI to shift all dates (called by dateshift1 action).
   # Used by overview mode.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub date_shift_one {  sub date_shift_one {
     my ($r) = @_;      my ($r) = @_;
     my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
Line 4543  sub date_shift_one { Line 5563  sub date_shift_one {
     $r->print(&Apache::loncommon::end_page());      $r->print(&Apache::loncommon::end_page());
 }  }
   
   # UI to shift all dates (second form).
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub date_shift_two {  sub date_shift_two {
     my ($r) = @_;      my ($r) = @_;
     my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $dom = $env{'course.'.$env{'request.course.id'}.'.domain'};
Line 4570  sub date_shift_two { Line 5593  sub date_shift_two {
     $r->print(&Apache::loncommon::end_page());      $r->print(&Apache::loncommon::end_page());
 }  }
   
   # Returns the different components of a resourcedata key.
   # Keys: scope_type, scope, realm_type, realm, realm_title,
   #       realm_exists, parameter_part, parameter_name.
   # Was used by clean_parameters (which is unused).
   #
   # @param {string} $key - the parameter key
   # @returns {hash}
 sub parse_key {  sub parse_key {
     my ($key) = @_;      my ($key) = @_;
     my %data;      my %data;
     my ($middle,$part,$name)=      my ($middle,$part,$name)=
     ($key=~/^$env{'request.course.id'}\.(?:(.+)\.)*([\w\s]+)\.(\w+)$/);      ($key=~/^$env{'request.course.id'}\.(?:(.+)\.)*([\w\s\-]+)\.(\w+)$/);
     $data{'scope_type'} = 'all';      $data{'scope_type'} = 'all';
     if ($middle=~/^\[(.*)\]/) {      if ($middle=~/^\[(.*)\]/) {
            $data{'scope'} = $1;          $data{'scope'} = $1;
     if ($data{'scope'}=~/^useropt\:($match_username)\:($match_domain)/) {          if ($data{'scope'}=~/^useropt\:($match_username)\:($match_domain)/) {
         $data{'scope_type'} = 'user';              $data{'scope_type'} = 'user';
         $data{'scope'} = [$1,$2];              $data{'scope'} = [$1,$2];
     } else {          } else {
         #FIXME check for group scope              $data{'scope_type'} = 'secgroup';
         $data{'scope_type'} = 'section';          }
     }          $middle=~s/^\[(.*)\]//;
     $middle=~s/^\[(.*)\]//;  
     }      }
     $middle=~s/\.+$//;      $middle=~s/\.+$//;
     $middle=~s/^\.+//;      $middle=~s/^\.+//;
     $data{'realm_type'}='all';      $data{'realm_type'}='all';
     if ($middle=~/^(.+)\_\_\_\(all\)$/) {      if ($middle=~/^(.+)\_\_\_\(all\)$/) {
     $data{'realm'} = $1;          $data{'realm'} = $1;
     $data{'realm_type'} = 'folder';          $data{'realm_type'} = 'folder';
     $data{'realm_title'} = &Apache::lonnet::gettitle($data{'realm'});          $data{'realm_title'} = &Apache::lonnet::gettitle($data{'realm'});
     ($data{'realm_exists'}) = &Apache::lonnet::is_on_map($data{'realm'});          ($data{'realm_exists'}) = &Apache::lonnet::is_on_map($data{'realm'});
     } elsif ($middle) {      } elsif ($middle) {
     $data{'realm'} = $middle;          $data{'realm'} = $middle;
     $data{'realm_type'} = 'symb';          $data{'realm_type'} = 'symb';
     $data{'realm_title'} = &Apache::lonnet::gettitle($data{'realm'});          $data{'realm_title'} = &Apache::lonnet::gettitle($data{'realm'});
     my ($map,$resid,$url) = &Apache::lonnet::decode_symb($data{'realm'});          my ($map,$resid,$url) = &Apache::lonnet::decode_symb($data{'realm'});
     $data{'realm_exists'} = &Apache::lonnet::symbverify($data{'realm'},$url);          $data{'realm_exists'} = &Apache::lonnet::symbverify($data{'realm'},$url);
     }      }
   
     $data{'parameter_part'} = $part;      $data{'parameter_part'} = $part;
Line 4610  sub parse_key { Line 5639  sub parse_key {
 }  }
   
   
   # Calls loncommon::start_page with the "Settings" title.
 sub header {  sub header {
     return &Apache::loncommon::start_page('Settings');      return &Apache::loncommon::start_page('Settings');
 }  }
   
   
   
   ##################################################
   # MAIN MENU
   ##################################################
   
   # Content and problem settings main menu.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {boolean} $parm_permission - true if the user has permission to edit the current course or section
 sub print_main_menu {  sub print_main_menu {
     my ($r,$parm_permission)=@_;      my ($r,$parm_permission)=@_;
     #      #
Line 4635  ENDMAINFORMHEAD Line 5673  ENDMAINFORMHEAD
     my $vgr  = &Apache::lonnet::allowed('vgr',$env{'request.course.id'});      my $vgr  = &Apache::lonnet::allowed('vgr',$env{'request.course.id'});
     my $mgr  = &Apache::lonnet::allowed('mgr',$env{'request.course.id'});      my $mgr  = &Apache::lonnet::allowed('mgr',$env{'request.course.id'});
     my $dcm = &Apache::lonnet::allowed('dcm',$env{'request.course.id'});      my $dcm = &Apache::lonnet::allowed('dcm',$env{'request.course.id'});
       my $vcb = &Apache::lonnet::allowed('vcb',$env{'request.course.id'});
       my $vpa = &Apache::lonnet::allowed('vpa',$env{'request.course.id'});
     if ((!$dcm) && ($env{'request.course.sec'} ne '')) {      if ((!$dcm) && ($env{'request.course.sec'} ne '')) {
         $dcm = &Apache::lonnet::allowed('dcm',$env{'request.course.id'}.          $dcm = &Apache::lonnet::allowed('dcm',$env{'request.course.id'}.
                                         '/'.$env{'request.course.sec'});                                          '/'.$env{'request.course.sec'});
     }      }
       if ((!$vcb) && ($env{'request.course.sec'} ne '')) {
           $vcb = &Apache::lonnet::allowed('vcb',$env{'request.course.id'}.
                                           '/'.$env{'request.course.sec'});
       }
       my (%linktext,%linktitle,%url);
       if ($parm_permission->{'edit'}) {
           %linktext = (
                        newoverview     => 'Edit Resource Parameters - Overview Mode',
                        settable        => 'Edit Resource Parameters - Table Mode',
                        setoverview     => 'Modify Resource Parameters - Overview Mode',
                       );
           %linktitle = (
                        newoverview     => 'Set/Modify resource parameters in overview mode.',
                        settable        => 'Set/Modify resource parameters in table mode.',
                        setoverview     => 'Set/Modify existing resource parameters in overview mode.',
                        );
       } else {
           %linktext = (
                        newoverview     => 'View Resource Parameters - Overview Mode',
                        settable        => 'View Resource Parameters - Table Mode',
                        setoverview     => 'View Resource Parameters - Overview Mode',
                      );
           %linktitle = (
                        newoverview     => 'Display resource parameters in overview mode.',
                        settable        => 'Display resource parameters in table mode.',
                        setoverview     => 'Display existing resource parameters in overview mode.',
                        );
       }
       if ($mgr) {
           $linktext{'resettimes'} = 'Reset Student Access Times';
           $linktitle{'resettimes'} = "Reset access times for folders/maps, resources or the $lc_crstype.";
           $url{'resettimes'} = '/adm/helper/resettimes.helper';
       } elsif ($vgr) {
           $linktext{'resettimes'} = 'Display Student Access Times',
           $linktitle{'resettimes'} = "Display access times for folders/maps, resources or the $lc_crstype.",
           $url{'resettimes'} = '/adm/accesstimes';
       }
     my @menu =      my @menu =
         ( { categorytitle=>"Content Settings for this $crstype",          ( { categorytitle=>"Content Settings for this $crstype",
         items => [          items => [
           { linktext => 'Portfolio Metadata',            { linktext => 'Portfolio Metadata',
             url => '/adm/parmset?action=setrestrictmeta',              url => '/adm/parmset?action=setrestrictmeta',
             permission => $parm_permission,              permission => $parm_permission->{'setrestrictmeta'},
             linktitle => "Restrict metadata for this $lc_crstype." ,              linktitle => "Restrict metadata for this $lc_crstype." ,
             icon =>'contact-new.png'   ,              icon =>'contact-new.png'   ,
             },              },
           { linktext => 'Reset Student Access Times',            { linktext => $linktext{'resettimes'},
             url => '/adm/helper/resettimes.helper',              url => $url{'resettimes'},
             permission => $mgr,              permission => ($vgr || $mgr),
             linktitle => "Reset access times for folders/maps, resources or the $lc_crstype."  ,              linktitle => $linktitle{'resettimes'},
             icon => 'start-here.png'  ,              icon => 'start-here.png',
             },              },
           { linktext => 'Blocking Communication/Resource Access',            { linktext => 'Blocking Communication/Resource Access',
             url => '/adm/setblock',              url => '/adm/setblock',
             permission => $dcm,              permission => ($vcb || $dcm),
             linktitle => 'Configure blocking of communication/collaboration and access to resources during an exam',              linktitle => 'Configure blocking of communication/collaboration and access to resources during an exam',
             icon => 'comblock.png',              icon => 'comblock.png',
             },              },
           { linktext => 'Set Parameter Setting Default Actions',            { linktext => 'Set Parameter Setting Default Actions',
             url => '/adm/parmset?action=setdefaults',              url => '/adm/parmset?action=setdefaults',
             permission => $parm_permission,              permission => $parm_permission->{'setdefaults'},
             linktitle =>'Set default actions for parameters.'  ,              linktitle =>'Set default actions for parameters.'  ,
             icon => 'folder-new.png'  ,              icon => 'folder-new.png'  ,
             }]},              }]},
Line 4671  ENDMAINFORMHEAD Line 5747  ENDMAINFORMHEAD
         items => [          items => [
           { linktext => 'Edit Resource Parameters - Helper Mode',            { linktext => 'Edit Resource Parameters - Helper Mode',
             url => '/adm/helper/parameter.helper',              url => '/adm/helper/parameter.helper',
             permission => $parm_permission,              permission => $parm_permission->{'helper'},
             linktitle =>'Set/Modify resource parameters in helper mode.'  ,              linktitle =>'Set/Modify resource parameters in helper mode.'  ,
             icon => 'dialog-information.png'  ,              icon => 'dialog-information.png'  ,
             #help => 'Parameter_Helper',              #help => 'Parameter_Helper',
             },              },
           { linktext => 'Edit Resource Parameters - Overview Mode',            { linktext => $linktext{'newoverview'},
             url => '/adm/parmset?action=newoverview',              url => '/adm/parmset?action=newoverview',
             permission => $parm_permission,              permission => $parm_permission->{'newoverview'},
             linktitle =>'Set/Modify resource parameters in overview mode.'  ,              linktitle => $linktitle{'newoverview'},
             icon => 'edit-find.png'  ,              icon => 'edit-find.png',
             #help => 'Parameter_Overview',              #help => 'Parameter_Overview',
             },              },
           { linktext => 'Edit Resource Parameters - Table Mode',            { linktext => $linktext{'settable'},
             url => '/adm/parmset?action=settable',              url => '/adm/parmset?action=settable',
             permission => $parm_permission,              permission => $parm_permission->{'settable'},
             linktitle =>'Set/Modify resource parameters in table mode.'  ,              linktitle => $linktitle{'settable'},
             icon => 'edit-copy.png'  ,              icon => 'edit-copy.png',
             #help => 'Table_Mode',              #help => 'Table_Mode',
             }]},              }]},
            { categorytitle => 'Existing Parameter Settings for Resources',             { categorytitle => 'Existing Parameter Settings for Resources',
          items => [           items => [
           { linktext => 'Modify Resource Parameters - Overview Mode',            { linktext => $linktext{'setoverview'},
             url => '/adm/parmset?action=setoverview',              url => '/adm/parmset?action=setoverview',
             permission => $parm_permission,              permission => $parm_permission->{'setoverview'},
             linktitle =>'Set/Modify existing resource parameters in overview mode.'  ,              linktitle => $linktitle{'setoverview'},
             icon => 'preferences-desktop-wallpaper.png'  ,              icon => 'preferences-desktop-wallpaper.png',
             #help => 'Parameter_Overview',              #help => 'Parameter_Overview',
             },              },
           { linktext => 'Change Log',            { linktext => 'Change Log',
             url => '/adm/parmset?action=parameterchangelog',              url => '/adm/parmset?action=parameterchangelog',
             permission => $parm_permission,              permission => $parm_permission->{'parameterchangelog'},
             linktitle =>"View parameter and $lc_crstype blog posting/user notification change log."  ,              linktitle =>"View parameter and $lc_crstype blog posting/user notification change log."  ,
             icon => 'document-properties.png',              icon => 'document-properties.png',
             }]}              }]}
Line 4715  ENDMAINFORMHEAD Line 5791  ENDMAINFORMHEAD
   
   
   
   ##################################################
   # PORTFOLIO METADATA
   ##################################################
   
   # Prints HTML to edit an item of portfolio metadata. The HTML contains several td elements (no tr).
   # It looks like field titles are not localized.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
   # @param {string} $field_name - metadata field name
   # @param {string} $field_text - metadata field title, in English unless manually added
   # @param {boolean} $added_flag - true if the field was manually added
 sub output_row {  sub output_row {
     my ($r, $field_name, $field_text, $added_flag) = @_;      my ($r, $field_name, $field_text, $added_flag) = @_;
     my $output;      my $output;
Line 4736  sub output_row { Line 5823  sub output_row {
         $output .= '<td><strong>'.$field_text.':</strong></td>';          $output .= '<td><strong>'.$field_text.':</strong></td>';
         $output .= &Apache::loncommon::end_data_table_row();          $output .= &Apache::loncommon::end_data_table_row();
         foreach my $opt (@options) {          foreach my $opt (@options) {
         my $checked = ($options =~ m/$opt->[0]/) ? ' checked="checked" ' : '' ;              my $checked = ($options =~ m/$opt->[0]/) ? ' checked="checked" ' : '' ;
         $output .= &Apache::loncommon::continue_data_table_row();              $output .= &Apache::loncommon::continue_data_table_row();
         $output .= '<td>'.('&nbsp;' x 5).'<label>              $output .= '<td>'.('&nbsp;' x 5).'<label>
                    <input type="checkbox" name="'.                      <input type="checkbox" name="'.
                    $field_name.'_'.$opt->[0].'" value="yes"'.$checked.' />'.                      $field_name.'_'.$opt->[0].'" value="yes"'.$checked.' />'.
                    &mt($opt->[1]).'</label></td>';                      &mt($opt->[1]).'</label></td>';
         $output .= &Apache::loncommon::end_data_table_row();              $output .= &Apache::loncommon::end_data_table_row();
     }          }
         $output .= &Apache::loncommon::continue_data_table_row();          $output .= &Apache::loncommon::continue_data_table_row();
         $output .= '<td>'.('&nbsp;' x 10).'<input name="'.$field_name.'_values" type="text" value="'.$values.'" size="80" /></td>';          $output .= '<td>'.('&nbsp;' x 10).'<input name="'.$field_name.'_values" type="text" value="'.$values.'" size="80" /></td>';
         $output .= &Apache::loncommon::end_data_table_row();          $output .= &Apache::loncommon::end_data_table_row();
Line 4756  sub output_row { Line 5843  sub output_row {
             $multiple_checked = ' checked="checked"';              $multiple_checked = ' checked="checked"';
             $single_checked = '';              $single_checked = '';
         }          }
     $output .= &Apache::loncommon::continue_data_table_row();          $output .= &Apache::loncommon::continue_data_table_row();
     $output .= '<td>'.('&nbsp;' x 10).'          $output .= '<td>'.('&nbsp;' x 10).'
                 <input type="radio" name="'.$field_name.'_onlyone" value="multiple"'.$multiple_checked .' />                      <input type="radio" name="'.$field_name.'_onlyone" value="multiple"'.$multiple_checked .' />
                 '.&mt('Student may select multiple choices from list').'</td>';                      '.&mt('Student may select multiple choices from list').'</td>';
     $output .= &Apache::loncommon::end_data_table_row();          $output .= &Apache::loncommon::end_data_table_row();
     $output .= &Apache::loncommon::continue_data_table_row();          $output .= &Apache::loncommon::continue_data_table_row();
     $output .= '<td>'.('&nbsp;' x 10).'          $output .= '<td>'.('&nbsp;' x 10).'
                 <input type="radio" name="'.$field_name.'_onlyone"  value="single"'.$single_checked.' />                      <input type="radio" name="'.$field_name.'_onlyone"  value="single"'.$single_checked.' />
                 '.&mt('Student may select only one choice from list').'</td>';                      '.&mt('Student may select only one choice from list').'</td>';
     $output .= &Apache::loncommon::end_data_table_row();          $output .= &Apache::loncommon::end_data_table_row();
     }      }
     return ($output);      return ($output);
 }  }
   
   
   # UI to order portfolio metadata fields.
   # Currently useless because addmetafield does not work.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub order_meta_fields {  sub order_meta_fields {
     my ($r)=@_;      my ($r)=@_;
     my $idx = 1;      my $idx = 1;
Line 4779  sub order_meta_fields { Line 5869  sub order_meta_fields {
     my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};      my $crs = $env{'course.'.$env{'request.course.id'}.'.num'};
     my $crstype = $env{'course.'.$env{'request.course.id'}.'.type'};;      my $crstype = $env{'course.'.$env{'request.course.id'}.'.type'};;
     $r->print(&Apache::loncommon::start_page('Order Metadata Fields'));      $r->print(&Apache::loncommon::start_page('Order Metadata Fields'));
     &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=addmetadata',      &Apache::lonhtmlcommon::add_breadcrumb(
           {href=>'/adm/parmset?action=addmetadata',
         text=>"Add Metadata Field"});          text=>"Add Metadata Field"});
     &Apache::lonhtmlcommon::add_breadcrumb      &Apache::lonhtmlcommon::add_breadcrumb(
             ({href=>"/adm/parmset?action=setrestrictmeta",          {href=>"/adm/parmset?action=setrestrictmeta",
               text=>"Restrict Metadata"},          text=>"Restrict Metadata"},
              {text=>"Order Metadata"});          {text=>"Order Metadata"});
     $r->print(&Apache::lonhtmlcommon::breadcrumbs('Order Metadata'));      $r->print(&Apache::lonhtmlcommon::breadcrumbs('Order Metadata'));
     &startSettingsScreen($r,'parmset',$crstype);      &startSettingsScreen($r,'parmset',$crstype);
     if ($env{'form.storeorder'}) {      if ($env{'form.storeorder'}) {
Line 4796  sub order_meta_fields { Line 5887  sub order_meta_fields {
         if ($newpos > $currentpos) {          if ($newpos > $currentpos) {
         # moving stuff up          # moving stuff up
             for ($i=0;$i<$currentpos;$i++) {              for ($i=0;$i<$currentpos;$i++) {
             $neworder[$i]=$oldorder[$i];                  $neworder[$i]=$oldorder[$i];
             }              }
             for ($i=$currentpos;$i<$newpos;$i++) {              for ($i=$currentpos;$i<$newpos;$i++) {
             $neworder[$i]=$oldorder[$i+1];                  $neworder[$i]=$oldorder[$i+1];
             }              }
             $neworder[$newpos]=$oldorder[$currentpos];              $neworder[$newpos]=$oldorder[$currentpos];
             for ($i=$newpos+1;$i<=$#oldorder;$i++) {              for ($i=$newpos+1;$i<=$#oldorder;$i++) {
             $neworder[$i]=$oldorder[$i];                  $neworder[$i]=$oldorder[$i];
             }              }
         } else {          } else {
         # moving stuff down          # moving stuff down
Line 4818  sub order_meta_fields { Line 5909  sub order_meta_fields {
                 $neworder[$i]=$oldorder[$i];                  $neworder[$i]=$oldorder[$i];
             }              }
         }          }
     my $ordered_fields = join ",", @neworder;          my $ordered_fields = join ",", @neworder;
         my $put_result = &Apache::lonnet::put('environment',          my $put_result = &Apache::lonnet::put('environment',
                            {'metadata.addedorder'=>$ordered_fields},$dom,$crs);                          {'metadata.addedorder'=>$ordered_fields},$dom,$crs);
     &Apache::lonnet::appenv({'course.'.$env{'request.course.id'}.'.metadata.addedorder' => $ordered_fields});          &Apache::lonnet::appenv({'course.'.$env{'request.course.id'}.'.metadata.addedorder' => $ordered_fields});
     }      }
     my $fields = &get_added_meta_fieldnames($env{'request.course.id'});      my $fields = &get_added_meta_fieldnames($env{'request.course.id'});
     my $ordered_fields;      my $ordered_fields;
Line 4861  sub order_meta_fields { Line 5952  sub order_meta_fields {
 }  }
   
   
   # Returns HTML with a Continue button redirecting to the initial portfolio metadata screen.
   # @returns {string}
 sub continue {  sub continue {
     my $output;      my $output;
     $output .= '<form action="" method="post">';      $output .= '<form action="" method="post">';
Line 4870  sub continue { Line 5963  sub continue {
 }  }
   
   
   # UI to add a metadata field.
   # Currenly does not work because of an HTML error (the field is not visible).
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub addmetafield {  sub addmetafield {
     my ($r)=@_;      my ($r)=@_;
     &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=addmetadata',      &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=addmetadata',
Line 4909  sub addmetafield { Line 6006  sub addmetafield {
             $r->print('You may undelete previously deleted fields.<br />Check those you wish to undelete and click Undelete.<br />');              $r->print('You may undelete previously deleted fields.<br />Check those you wish to undelete and click Undelete.<br />');
             $r->print('<form method="post" action="">');              $r->print('<form method="post" action="">');
             foreach my $key(keys(%$fields)) {              foreach my $key(keys(%$fields)) {
                 $r->print('<input type="checkbox" name="undeletefield" value="'.$key.'" />'.$$fields{$key}.'<br /');                  $r->print('<label><input type="checkbox" name="undeletefield" value="'.$key.'" />'.$$fields{$key}.'</label><br /');
             }              }
             $r->print('<input type="submit" name="undelete" value="Undelete" />');              $r->print('<input type="submit" name="undelete" value="Undelete" />');
             $r->print('</form>');              $r->print('</form>');
         }          }
         $r->print('<hr /><strong>Or</strong> you may enter a new metadata field name.<form method="post" action="/adm/parmset?action=addmetadata"');          $r->print('<hr /><strong>Or</strong> you may enter a new metadata field name.'.
                     '<form method="post" action="/adm/parmset?action=addmetadata">');
         $r->print('<input type="text" name="fieldname" /><br />');          $r->print('<input type="text" name="fieldname" /><br />');
         $r->print('<input type="submit" value="Add Metadata Field" />');          $r->print('<input type="submit" value="Add Metadata Field" />');
           $r->print('</form>');
     }      }
     $r->print('</form>');  
     &endSettingsScreen($r);      &endSettingsScreen($r);
 }  }
   
   
   
   # Display or save portfolio metadata.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub setrestrictmeta {  sub setrestrictmeta {
     my ($r)=@_;      my ($r)=@_;
     my $next_meta;      my $next_meta;
Line 4964  sub setrestrictmeta { Line 6065  sub setrestrictmeta {
                         $options.='deleted,';                          $options.='deleted,';
                     }                      }
                     my $name = $save_field;                      my $name = $save_field;
                      $put_result = &Apache::lonnet::put('environment',                      $put_result = &Apache::lonnet::put('environment',
                                                   {'metadata.'.$meta_field.'.options'=>$options,                          {'metadata.'.$meta_field.'.options'=>$options,
                                                    'metadata.'.$meta_field.'.values'=>$env{'form.'.$meta_field.'_values'},                          'metadata.'.$meta_field.'.values'=>$env{'form.'.$meta_field.'_values'},
                                                    },$dom,$crs);                          },$dom,$crs);
                 }                  }
             }              }
         }          }
Line 4983  sub setrestrictmeta { Line 6084  sub setrestrictmeta {
     foreach my $field (sort(keys(%metadata_fields))) {      foreach my $field (sort(keys(%metadata_fields))) {
         if ($field ne 'courserestricted') {          if ($field ne 'courserestricted') {
             $row_alt = $row_alt ? 0 : 1;              $row_alt = $row_alt ? 0 : 1;
         $output.= &output_row($r, $field, $metadata_fields{$field});              $output.= &output_row($r, $field, $metadata_fields{$field});
     }          }
     }      }
     my $buttons = (<<ENDButtons);      my $buttons = (<<ENDButtons);
         <input type="submit" name="restrictmeta" value="Save" />          <input type="submit" name="restrictmeta" value="Save" />
Line 4999  ENDButtons Line 6100  ENDButtons
     my $added_flag = 1;      my $added_flag = 1;
     foreach my $field (sort(keys(%$added_metadata_fields))) {      foreach my $field (sort(keys(%$added_metadata_fields))) {
         $row_alt = $row_alt ? 0 : 1;          $row_alt = $row_alt ? 0 : 1;
         $output.= &output_row($r, $field, $$added_metadata_fields{$field},$added_flag, $row_alt);          $output.= &output_row($r, $field, $$added_metadata_fields{$field},$added_flag, $row_alt); # FIXME: wrong parameters
     }      }
     $output .= &Apache::loncommon::end_data_table();      $output .= &Apache::loncommon::end_data_table();
     $r->print(<<ENDenv);      $r->print(<<ENDenv);
Line 5014  ENDenv Line 6115  ENDenv
 }  }
   
   
   # Returns metadata fields that have been manually added.
   #
   # @param {string} $cid - course id
   # @returns {hash reference} - hash field name -> field title (not localized)
 sub get_added_meta_fieldnames {  sub get_added_meta_fieldnames {
     my ($cid) = @_;      my ($cid) = @_;
     my %fields;      my %fields;
Line 5029  sub get_added_meta_fieldnames { Line 6133  sub get_added_meta_fieldnames {
 }  }
   
   
   # Returns metadata fields that have been manually added and deleted.
   #
   # @param {string} $cid - course id
   # @returns {hash reference} - hash field name -> field title (not localized)
 sub get_deleted_meta_fieldnames {  sub get_deleted_meta_fieldnames {
     my ($cid) = @_;      my ($cid) = @_;
     my %fields;      my %fields;
Line 5044  sub get_deleted_meta_fieldnames { Line 6151  sub get_deleted_meta_fieldnames {
     }      }
     return \%fields;      return \%fields;
 }  }
   
   
   ##################################################
   # PARAMETER SETTINGS DEFAULT ACTIONS
   ##################################################
   
   # UI to change parameter setting default actions
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub defaultsetter {  sub defaultsetter {
     my ($r) = @_;      my ($r) = @_;
   
Line 5076  sub defaultsetter { Line 6192  sub defaultsetter {
                 \%mapp, \%symbp,\%maptitles,\%uris,                  \%mapp, \%symbp,\%maptitles,\%uris,
                 \%keyorder,\%defkeytype);                  \%keyorder,\%defkeytype);
     if ($env{'form.storerules'}) {      if ($env{'form.storerules'}) {
     my %newrules=();          my %newrules=();
     my @delrules=();          my @delrules=();
     my %triggers=();          my %triggers=();
     foreach my $key (keys(%env)) {          foreach my $key (keys(%env)) {
             if ($key=~/^form\.(\w+)\_action$/) {              if ($key=~/^form\.(\w+)\_action$/) {
         my $tempkey=$1;                  my $tempkey=$1;
         my $action=$env{$key};                  my $action=$env{$key};
                 if ($action) {                  if ($action) {
             $newrules{$tempkey.'_action'}=$action;                      $newrules{$tempkey.'_action'}=$action;
             if ($action ne 'default') {                      if ($action ne 'default') {
             my ($whichaction,$whichparm)=($action=~/^(.*\_)([^\_]+)$/);                          my ($whichaction,$whichparm)=($action=~/^(.*\_)([^\_]+)$/);
             $triggers{$whichparm}.=$tempkey.':';                          $triggers{$whichparm}.=$tempkey.':';
             }                      }
             $newrules{$tempkey.'_type'}=$defkeytype{$tempkey};                      $newrules{$tempkey.'_type'}=$defkeytype{$tempkey};
             if (&isdateparm($defkeytype{$tempkey})) {                      if (&isdateparm($defkeytype{$tempkey})) {
             $newrules{$tempkey.'_days'}=$env{'form.'.$tempkey.'_days'};                          $newrules{$tempkey.'_days'}=$env{'form.'.$tempkey.'_days'};
             $newrules{$tempkey.'_hours'}=$env{'form.'.$tempkey.'_hours'};                          $newrules{$tempkey.'_hours'}=$env{'form.'.$tempkey.'_hours'};
             $newrules{$tempkey.'_min'}=$env{'form.'.$tempkey.'_min'};                          $newrules{$tempkey.'_min'}=$env{'form.'.$tempkey.'_min'};
             $newrules{$tempkey.'_sec'}=$env{'form.'.$tempkey.'_sec'};                          $newrules{$tempkey.'_sec'}=$env{'form.'.$tempkey.'_sec'};
             } else {                      } else {
             $newrules{$tempkey.'_value'}=$env{'form.'.$tempkey.'_value'};                          $newrules{$tempkey.'_value'}=$env{'form.'.$tempkey.'_value'};
             $newrules{$tempkey.'_triggervalue'}=$env{'form.'.$tempkey.'_triggervalue'};                          $newrules{$tempkey.'_triggervalue'}=$env{'form.'.$tempkey.'_triggervalue'};
                       }
                   } else {
                       push(@delrules,$tempkey.'_action');
                       push(@delrules,$tempkey.'_type');
                       push(@delrules,$tempkey.'_hours');
                       push(@delrules,$tempkey.'_min');
                       push(@delrules,$tempkey.'_sec');
                       push(@delrules,$tempkey.'_value');
                   }
             }              }
         } else {  
             push(@delrules,$tempkey.'_action');  
             push(@delrules,$tempkey.'_type');  
             push(@delrules,$tempkey.'_hours');  
             push(@delrules,$tempkey.'_min');  
             push(@delrules,$tempkey.'_sec');  
             push(@delrules,$tempkey.'_value');  
         }          }
           foreach my $key (keys(%allparms)) {
               $newrules{$key.'_triggers'}=$triggers{$key};
         }          }
     }          &Apache::lonnet::put('parmdefactions',\%newrules,$cdom,$cnum);
     foreach my $key (keys(%allparms)) {          &Apache::lonnet::del('parmdefactions',\@delrules,$cdom,$cnum);
         $newrules{$key.'_triggers'}=$triggers{$key};          &resetrulescache();
     }  
     &Apache::lonnet::put('parmdefactions',\%newrules,$cdom,$cnum);  
     &Apache::lonnet::del('parmdefactions',\@delrules,$cdom,$cnum);  
     &resetrulescache();  
     }      }
     my %lt=&Apache::lonlocal::texthash('days' => 'Days',      my %lt=&Apache::lonlocal::texthash('days' => 'Days',
                        'hours' => 'Hours',                         'hours' => 'Hours',
Line 5127  sub defaultsetter { Line 6243  sub defaultsetter {
     my @dateoptions=('','default');      my @dateoptions=('','default');
     my @datedisplay=('',&mt('Default value when manually setting'));      my @datedisplay=('',&mt('Default value when manually setting'));
     foreach my $tempkey (&keysindisplayorder(\%allparms,\%keyorder)) {      foreach my $tempkey (&keysindisplayorder(\%allparms,\%keyorder)) {
     unless ($tempkey) { next; }          unless ($tempkey) { next; }
     push @standardoptions,'when_setting_'.$tempkey;          push @standardoptions,'when_setting_'.$tempkey;
     push @standarddisplay,&mt('Automatically set when setting ').$tempkey;          push @standarddisplay,&mt('Automatically set when setting ').$tempkey;
     if (&isdateparm($defkeytype{$tempkey})) {          if (&isdateparm($defkeytype{$tempkey})) {
         push @dateoptions,'later_than_'.$tempkey;              push @dateoptions,'later_than_'.$tempkey;
         push @datedisplay,&mt('Automatically set later than ').$tempkey;              push @datedisplay,&mt('Automatically set later than ').$tempkey;
         push @dateoptions,'earlier_than_'.$tempkey;              push @dateoptions,'earlier_than_'.$tempkey;
         push @datedisplay,&mt('Automatically set earlier than ').$tempkey;              push @datedisplay,&mt('Automatically set earlier than ').$tempkey;
     }          }
     }      }
 $r->print(&mt('Manual setting rules apply to all interfaces.').'<br />'.      $r->print(&mt('Manual setting rules apply to all interfaces.').'<br />'.
       &mt('Automatic setting rules apply to table mode interfaces only.'));          &mt('Automatic setting rules apply to table mode interfaces only.'));
     $r->print("\n".&Apache::loncommon::start_data_table().      $r->print("\n".&Apache::loncommon::start_data_table().
           &Apache::loncommon::start_data_table_header_row().            &Apache::loncommon::start_data_table_header_row().
           "<th>".&mt('Rule for parameter').'</th><th>'.            "<th>".&mt('Rule for parameter').'</th><th>'.
           &mt('Action').'</th><th>'.&mt('Value').'</th>'.            &mt('Action').'</th><th>'.&mt('Value').'</th>'.
           &Apache::loncommon::end_data_table_header_row());            &Apache::loncommon::end_data_table_header_row());
     foreach my $tempkey (&keysindisplayorder(\%allparms,\%keyorder)) {      foreach my $tempkey (&keysindisplayorder(\%allparms,\%keyorder)) {
     unless ($tempkey) { next; }          unless ($tempkey) { next; }
     $r->print("\n".&Apache::loncommon::start_data_table_row().          $r->print("\n".&Apache::loncommon::start_data_table_row().
           "<td>".$allparms{$tempkey}."\n<br />(".$tempkey.')</td><td>');              "<td>".$allparms{$tempkey}."\n<br />(".$tempkey.')</td><td>');
     my $action=&rulescache($tempkey.'_action');          my $action=&rulescache($tempkey.'_action');
     $r->print('<select name="'.$tempkey.'_action">');          $r->print('<select name="'.$tempkey.'_action">');
     if (&isdateparm($defkeytype{$tempkey})) {          if (&isdateparm($defkeytype{$tempkey})) {
         for (my $i=0;$i<=$#dateoptions;$i++) {              for (my $i=0;$i<=$#dateoptions;$i++) {
         if ($dateoptions[$i]=~/\_$tempkey$/) { next; }              if ($dateoptions[$i]=~/\_$tempkey$/) { next; }
         $r->print("\n<option value='$dateoptions[$i]'".              $r->print("\n<option value='$dateoptions[$i]'".
               ($dateoptions[$i] eq $action?' selected="selected"':'').                  ($dateoptions[$i] eq $action?' selected="selected"':'').
               ">$datedisplay[$i]</option>");                  ">$datedisplay[$i]</option>");
               }
           } else {
               for (my $i=0;$i<=$#standardoptions;$i++) {
               if ($standardoptions[$i]=~/\_$tempkey$/) { next; }
               $r->print("\n<option value='$standardoptions[$i]'".
                   ($standardoptions[$i] eq $action?' selected="selected"':'').
                   ">$standarddisplay[$i]</option>");
               }
         }          }
     } else {          $r->print('</select>');
         for (my $i=0;$i<=$#standardoptions;$i++) {          unless (&isdateparm($defkeytype{$tempkey})) {
         if ($standardoptions[$i]=~/\_$tempkey$/) { next; }              $r->print("\n<br />".&mt('Triggering value(s) of other parameter (optional, comma-separated):').
         $r->print("\n<option value='$standardoptions[$i]'".                  '<input type="text" size="20" name="'.$tempkey.'_triggervalue" value="'.&rulescache($tempkey.'_triggervalue').'" />');
               ($standardoptions[$i] eq $action?' selected="selected"':'').  
               ">$standarddisplay[$i]</option>");  
         }          }
     }          $r->print("\n</td><td>\n");
     $r->print('</select>');  
     unless (&isdateparm($defkeytype{$tempkey})) {  
         $r->print("\n<br />".&mt('Triggering value(s) of other parameter (optional, comma-separated):').  
               '<input type="text" size="20" name="'.$tempkey.'_triggervalue" value="'.&rulescache($tempkey.'_triggervalue').'" />');  
     }  
     $r->print("\n</td><td>\n");  
   
         if (&isdateparm($defkeytype{$tempkey})) {          if (&isdateparm($defkeytype{$tempkey})) {
         my $days=&rulescache($tempkey.'_days');              my $days=&rulescache($tempkey.'_days');
         my $hours=&rulescache($tempkey.'_hours');              my $hours=&rulescache($tempkey.'_hours');
         my $min=&rulescache($tempkey.'_min');              my $min=&rulescache($tempkey.'_min');
         my $sec=&rulescache($tempkey.'_sec');              my $sec=&rulescache($tempkey.'_sec');
         $r->print(<<ENDINPUTDATE);              $r->print(<<ENDINPUTDATE);
 <input name="$tempkey\_days" type="text" size="4" value="$days" />$lt{'days'}<br />      <input name="$tempkey\_days" type="text" size="4" value="$days" />$lt{'days'}<br />
 <input name="$tempkey\_hours" type="text" size="4" value="$hours" />$lt{'hours'}<br />      <input name="$tempkey\_hours" type="text" size="4" value="$hours" />$lt{'hours'}<br />
 <input name="$tempkey\_min" type="text" size="4" value="$min" />$lt{'min'}<br />      <input name="$tempkey\_min" type="text" size="4" value="$min" />$lt{'min'}<br />
 <input name="$tempkey\_sec" type="text" size="4" value="$sec" />$lt{'sec'}      <input name="$tempkey\_sec" type="text" size="4" value="$sec" />$lt{'sec'}
 ENDINPUTDATE  ENDINPUTDATE
     } elsif ($defkeytype{$tempkey} eq 'string_yesno') {          } elsif ($defkeytype{$tempkey} eq 'string_yesno') {
             my $yeschecked='';                  my $yeschecked='';
             my $nochecked='';                  my $nochecked='';
             if (&rulescache($tempkey.'_value') eq 'yes') { $yeschecked=' checked="checked"'; }                  if (&rulescache($tempkey.'_value') eq 'yes') { $yeschecked=' checked="checked"'; }
             if (&rulescache($tempkey.'_value') eq 'no') { $nochecked=' checked="checked"'; }                  if (&rulescache($tempkey.'_value') eq 'no') { $nochecked=' checked="checked"'; }
   
         $r->print(<<ENDYESNO);              $r->print(<<ENDYESNO);
 <label><input type="radio" name="$tempkey\_value" value="yes"$yeschecked /> $lt{'yes'}</label><br />      <label><input type="radio" name="$tempkey\_value" value="yes"$yeschecked /> $lt{'yes'}</label><br />
 <label><input type="radio" name="$tempkey\_value" value="no"$nochecked /> $lt{'no'}</label>      <label><input type="radio" name="$tempkey\_value" value="no"$nochecked /> $lt{'no'}</label>
 ENDYESNO  ENDYESNO
         } else {          } else {
         $r->print('<input type="text" size="20" name="'.$tempkey.'_value" value="'.&rulescache($tempkey.'_value').'" />');              $r->print('<input type="text" size="20" name="'.$tempkey.'_value" value="'.&rulescache($tempkey.'_value').'" />');
     }          }
         $r->print('</td>'.&Apache::loncommon::end_data_table_row());          $r->print('</td>'.&Apache::loncommon::end_data_table_row());
     }      }
     $r->print(&Apache::loncommon::end_data_table().      $r->print(&Apache::loncommon::end_data_table().
Line 5206  ENDYESNO Line 6322  ENDYESNO
     return;      return;
 }  }
   
   ##################################################
   # PARAMETER CHANGES LOG
   ##################################################
   
   # Returns some info for a parameter log entry.
   # Returned entries:
   # $realm - HTML title for the parameter level and resource
   # $section - parameter section
   # $name - parameter name
   # $part - parameter part
   # $what - $part.'.'.$name
   # $middle - resource symb ?
   # $uname - user name (same as given)
   # $udom - user domain (same as given)
   # $issection - section or group name
   # $realmdescription - title for the parameter level and resource (without using HTML)
   #
   # @param {string} $key - parameter log key
   # @param {string} $uname - user name
   # @param {string} $udom - user domain
   # @param {boolean} $typeflag - .type log entry
   # @returns {Array}
 sub components {  sub components {
     my ($key,$uname,$udom,$exeuser,$exedomain,$typeflag)=@_;      my ($key,$uname,$udom,$typeflag)=@_;
   
     if ($typeflag) {      if ($typeflag) {
     $key=~s/\.type$//;          $key=~s/\.type$//;
     }      }
   
     my ($middle,$part,$name)=      my ($middle,$part,$name)=
     ($key=~/^$env{'request.course.id'}\.(?:(.+)\.)*([\w\s]+)\.(\w+)$/);          ($key=~/^$env{'request.course.id'}\.(?:(.+)\.)*([\w\s\-]+)\.(\w+)$/);
     my $issection;      my $issection;
   
     my $section=&mt('All Students');      my $section=&mt('All Students');
     if ($middle=~/^\[(.*)\]/) {      if ($middle=~/^\[(.*)\]/) {
     $issection=$1;          $issection=$1;
     $section=&mt('Group/Section').': '.$issection;          $section=&mt('Group/Section').': '.$issection;
     $middle=~s/^\[(.*)\]//;          $middle=~s/^\[(.*)\]//;
     }      }
     $middle=~s/\.+$//;      $middle=~s/\.+$//;
     $middle=~s/^\.+//;      $middle=~s/^\.+//;
     if ($uname) {      if ($uname) {
     $section=&mt('User').": ".&Apache::loncommon::plainname($uname,$udom);          $section=&mt('User').": ".&Apache::loncommon::plainname($uname,$udom);
     $issection='';          $issection='';
     }      }
     my $realm='<span class="LC_parm_scope_all">'.&mt('All Resources').'</span>';      my $realm='<span class="LC_parm_scope_all">'.&mt('All Resources').'</span>';
     my $realmdescription=&mt('all resources');      my $realmdescription=&mt('all resources');
Line 5238  sub components { Line 6376  sub components {
         if ($maplevel eq 'rec') {          if ($maplevel eq 'rec') {
             $leveltitle = &mt('Recursive');              $leveltitle = &mt('Recursive');
         }          }
     $realm='<span class="LC_parm_scope_folder">'.$leveltitle.': '.&Apache::lonnet::gettitle($mapurl).' <span class="LC_parm_folder"><br />('.$mapurl.')</span></span>';          $realm='<span class="LC_parm_scope_folder">'.$leveltitle.
      $realmdescription=&mt('folder').' '.&Apache::lonnet::gettitle($mapurl);              ': '.&Apache::lonnet::gettitle($mapurl).' <span class="LC_parm_folder"><br />('.
    } elsif ($middle) {              $mapurl.')</span></span>';
     my ($map,$id,$url)=&Apache::lonnet::decode_symb($middle);          $realmdescription=&mt('folder').' '.&Apache::lonnet::gettitle($mapurl);
     $realm='<span class="LC_parm_scope_resource">'.&mt('Resource').': '.&Apache::lonnet::gettitle($middle).' <br /><span class="LC_parm_symb">('.$url.' in '.$map.' id: '.$id.')</span></span>';      } elsif ($middle) {
     $realmdescription=&mt('resource').' '.&Apache::lonnet::gettitle($middle);          my ($map,$id,$url)=&Apache::lonnet::decode_symb($middle);
           $realm='<span class="LC_parm_scope_resource">'.&mt('Resource').
               ': '.&Apache::lonnet::gettitle($middle).' <br /><span class="LC_parm_symb">('.$url.
               ' in '.$map.' id: '.$id.')</span></span>';
           $realmdescription=&mt('resource').' '.&Apache::lonnet::gettitle($middle);
     }      }
     my $what=$part.'.'.$name;      my $what=$part.'.'.$name;
     return ($realm,$section,$name,$part,      return ($realm,$section,$name,$part,
         $what,$middle,$uname,$udom,$issection,$realmdescription);          $what,$middle,$uname,$udom,$issection,$realmdescription);
 }  }
   
 my %standard_parms;  my %standard_parms; # hash parameter name -> parameter title (not localized)
 my %standard_parms_types;  my %standard_parms_types; # hash parameter name -> parameter type
   
   # Reads parameter info from packages.tab into %standard_parms.
 sub load_parameter_names {  sub load_parameter_names {
     open(my $config,"<$Apache::lonnet::perlvar{'lonTabDir'}/packages.tab");      open(my $config,"<","$Apache::lonnet::perlvar{'lonTabDir'}/packages.tab");
     while (my $configline=<$config>) {      while (my $configline=<$config>) {
     if ($configline !~ /\S/ || $configline=~/^\#/) { next; }          if ($configline !~ /\S/ || $configline=~/^\#/) { next; }
     chomp($configline);          chomp($configline);
     my ($short,$plain)=split(/:/,$configline);          my ($short,$plain)=split(/:/,$configline);
     my (undef,$name,$type)=split(/\&/,$short,3);          my (undef,$name,$type)=split(/\&/,$short,3);
     if ($type eq 'display') {          if ($type eq 'display') {
         $standard_parms{$name} = $plain;              $standard_parms{$name} = $plain;
         } elsif ($type eq 'type') {          } elsif ($type eq 'type') {
             $standard_parms_types{$name} = $plain;                  $standard_parms_types{$name} = $plain;
         }          }
     }      }
     close($config);      close($config);
     $standard_parms{'int_pos'}      = 'Positive Integer';      $standard_parms{'int_pos'}      = 'Positive Integer';
     $standard_parms{'int_zero_pos'} = 'Positive Integer or Zero';      $standard_parms{'int_zero_pos'} = 'Positive Integer or Zero';
       $standard_parms{'scoreformat'}  = 'Format for display of score';
 }  }
   
   # Returns a parameter title for standard parameters, the name for others.
   #
   # @param {string} $name - parameter name
   # @returns {string}
 sub standard_parameter_names {  sub standard_parameter_names {
     my ($name)=@_;      my ($name)=@_;
     if (!%standard_parms) {      if (!%standard_parms) {
     &load_parameter_names();          &load_parameter_names();
     }      }
     if ($standard_parms{$name}) {      if ($standard_parms{$name}) {
     return $standard_parms{$name};          return $standard_parms{$name};
     } else {      } else {
     return $name;          return $name;
     }      }
 }  }
   
   # Returns a parameter type for standard parameters, undef for others.
   #
   # @param {string} $name - parameter name
   # @returns {string}
 sub standard_parameter_types {  sub standard_parameter_types {
     my ($name)=@_;      my ($name)=@_;
     if (!%standard_parms_types) {      if (!%standard_parms_types) {
Line 5294  sub standard_parameter_types { Line 6446  sub standard_parameter_types {
     return;      return;
 }  }
   
   # Returns a parameter level title (not localized) from the parameter level name.
   #
   # @param {string} $name - parameter level name (recognized: resourcelevel|maplevel|maplevelrecurse|courselevel)
   # @returns {string}
 sub standard_parameter_levels {  sub standard_parameter_levels {
     my ($name)=@_;      my ($name)=@_;
     my %levels = (      my %levels = (
Line 5308  sub standard_parameter_levels { Line 6464  sub standard_parameter_levels {
     return;      return;
 }  }
   
   # Display log for parameter changes, blog postings, user notification changes.
   #
   # @param {Apache2::RequestRec} $r - the Apache request
 sub parm_change_log {  sub parm_change_log {
     my ($r)=@_;      my ($r,$parm_permission)=@_;
     my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};      my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
     my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};      my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
     my $crstype = $env{'course.'.$env{'request.course.id'}.'.type'}      my $crstype = $env{'course.'.$env{'request.course.id'}.'.type'};
     &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=settable',      &Apache::lonhtmlcommon::add_breadcrumb({href=>'/adm/parmset?action=settable',
     text=>"Parameter Change Log"});      text=>"Parameter Change Log"});
     my $js = '<script type="text/javascript">'."\n".      my $js = '<script type="text/javascript">'."\n".
Line 5341  sub parm_change_log { Line 6500  sub parm_change_log {
               '<input type="submit" value="'.&mt('Display').'" />'.                '<input type="submit" value="'.&mt('Display').'" />'.
               '</form></fieldset></div><br clear="all" />');                '</form></fieldset></div><br clear="all" />');
   
       my $readonly = 1;
       if ($parm_permission->{'edit'}) {
           undef($readonly);
       }
     my $courseopt=&Apache::lonnet::get_courseresdata($cnum,$cdom);      my $courseopt=&Apache::lonnet::get_courseresdata($cnum,$cdom);
     $r->print(&Apache::loncommon::start_data_table().&Apache::loncommon::start_data_table_header_row().      $r->print(&Apache::loncommon::start_data_table().&Apache::loncommon::start_data_table_header_row().
           '<th>'.&mt('Time').'</th><th>'.&mt('User').'</th><th>'.&mt('Extent').'</th><th>'.&mt('Users').'</th><th>'.            '<th>'.&mt('Time').'</th><th>'.&mt('User').'</th><th>'.&mt('Extent').'</th><th>'.&mt('Users').'</th><th>'.
           &mt('Parameter').'</th><th>'.&mt('Part').'</th><th>'.&mt('New Value').'</th><th>'.&mt('Announce').'</th>'.            &mt('Parameter').'</th><th>'.&mt('Part').'</th><th>'.&mt('New Value').'</th>');
           &Apache::loncommon::end_data_table_header_row());      unless ($readonly) {
           $r->print('<th>'.&mt('Announce').'</th>');
       }
       $r->print(&Apache::loncommon::end_data_table_header_row());
     my $shown=0;      my $shown=0;
     my $folder='';      my $folder='';
     if ($env{'form.displayfilter'} eq 'currentfolder') {      if ($env{'form.displayfilter'} eq 'currentfolder') {
     my $last='';          my $last='';
     if (tie(my %hash,'GDBM_File',$env{'request.course.fn'}.'_symb.db',          if (tie(my %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) { ($folder) = &Apache::lonnet::decode_symb($last); }          if ($last) { ($folder) = &Apache::lonnet::decode_symb($last); }
     }      }
     foreach my $id (sort      foreach my $id (sort {
             {                  if ($parmlog{$b}{'exe_time'} ne $parmlog{$a}{'exe_time'}) {
             if ($parmlog{$b}{'exe_time'} ne $parmlog{$a}{'exe_time'}) {                      return $parmlog{$b}{'exe_time'} <=>$parmlog{$a}{'exe_time'}
                 return $parmlog{$b}{'exe_time'} <=>$parmlog{$a}{'exe_time'}                  }
             }                  my $aid = (split('00000',$a))[-1];
             my $aid = (split('00000',$a))[-1];                  my $bid = (split('00000',$b))[-1];
             my $bid = (split('00000',$b))[-1];                  return $bid<=>$aid;
             return $bid<=>$aid;  
             } (keys(%parmlog))) {              } (keys(%parmlog))) {
         my @changes=keys(%{$parmlog{$id}{'logentry'}});          my @changes=keys(%{$parmlog{$id}{'logentry'}});
     my $count = 0;          my $count = 0;
     my $time =          my $time =
         &Apache::lonlocal::locallocaltime($parmlog{$id}{'exe_time'});              &Apache::lonlocal::locallocaltime($parmlog{$id}{'exe_time'});
     my $plainname =          my $plainname =
         &Apache::loncommon::plainname($parmlog{$id}{'exe_uname'},              &Apache::loncommon::plainname($parmlog{$id}{'exe_uname'},
                       $parmlog{$id}{'exe_udom'});                          $parmlog{$id}{'exe_udom'});
     my $about_me_link =          my $about_me_link =
         &Apache::loncommon::aboutmewrapper($plainname,              &Apache::loncommon::aboutmewrapper($plainname,
                            $parmlog{$id}{'exe_uname'},                              $parmlog{$id}{'exe_uname'},
                            $parmlog{$id}{'exe_udom'});                              $parmlog{$id}{'exe_udom'});
     my $send_msg_link='';          my $send_msg_link='';
     if ((($parmlog{$id}{'exe_uname'} ne $env{'user.name'})          if ((!$readonly) && 
          || ($parmlog{$id}{'exe_udom'} ne $env{'user.domain'}))) {              (($parmlog{$id}{'exe_uname'} ne $env{'user.name'})
         $send_msg_link ='<br />'.              || ($parmlog{$id}{'exe_udom'} ne $env{'user.domain'}))) {
         &Apache::loncommon::messagewrapper(&mt('Send message'),              $send_msg_link ='<br />'.
                            $parmlog{$id}{'exe_uname'},              &Apache::loncommon::messagewrapper(&mt('Send message'),
                            $parmlog{$id}{'exe_udom'});                              $parmlog{$id}{'exe_uname'},
     }                              $parmlog{$id}{'exe_udom'});
     my $row_start=&Apache::loncommon::start_data_table_row();          }
     my $makenewrow=0;          my $row_start=&Apache::loncommon::start_data_table_row();
     my %istype=();          my $makenewrow=0;
     my $output;          my %istype=();
     foreach my $changed (reverse(sort(@changes))) {          my $output;
             my $value=$parmlog{$id}{'logentry'}{$changed};          foreach my $changed (reverse(sort(@changes))) {
         my $typeflag = ($changed =~/\.type$/ &&                  my $value=$parmlog{$id}{'logentry'}{$changed};
                 !exists($parmlog{$id}{'logentry'}{$changed.'.type'}));              my $typeflag = ($changed =~/\.type$/ &&
                       !exists($parmlog{$id}{'logentry'}{$changed.'.type'}));
             my ($realm,$section,$parmname,$part,$what,$middle,$uname,$udom,$issection,$realmdescription)=              my ($realm,$section,$parmname,$part,$what,$middle,$uname,$udom,$issection,$realmdescription)=
         &components($changed,$parmlog{$id}{'uname'},$parmlog{$id}{'udom'},undef,undef,$typeflag);                  &components($changed,$parmlog{$id}{'uname'},$parmlog{$id}{'udom'},$typeflag);
         if ($env{'request.course.sec'} ne '') {              if ($env{'request.course.sec'} ne '') {
             next if (($issection ne '') && ($issection ne $env{'request.course.sec'}));                  next if (($issection ne '') && ($issection ne $env{'request.course.sec'}));
             if ($uname ne '') {                  if ($uname ne '') {
                 my $stusection = &Apache::lonnet::getsection($uname,$udom,$env{'request.course.id'});                      my $stusection = &Apache::lonnet::getsection($uname,$udom,$env{'request.course.id'});
                 next if (($stusection ne '-1') && ($stusection ne $env{'request.course.sec'}));                       next if (($stusection ne '-1') && ($stusection ne $env{'request.course.sec'})); 
             }                  }
         }              }
         if ($env{'form.displayfilter'} eq 'currentfolder') {              if ($env{'form.displayfilter'} eq 'currentfolder') {
         if ($folder) {                  if ($folder) {
             if ($middle!~/^\Q$folder\E/) { next; }                      if ($middle!~/^\Q$folder\E/) { next; }
         }                  }
         }              }
         if ($typeflag) {              if ($typeflag) {
         $istype{$parmname}=$value;                  $istype{$parmname}=$value;
         if (!$env{'form.includetypes'}) { next; }                  if (!$env{'form.includetypes'}) { next; }
         }              }
         $count++;              $count++;
         if ($makenewrow) {              if ($makenewrow) {
         $output .= $row_start;                  $output .= $row_start;
         } else {              } else {
         $makenewrow=1;                  $makenewrow=1;
         }              }
             my $parmitem = &standard_parameter_names($parmname);              my $parmitem = &standard_parameter_names($parmname);
         $output .='<td>'.$realm.'</td><td>'.$section.'</td><td>'.              $output .='<td>'.$realm.'</td><td>'.$section.'</td><td>'.
               &mt($parmitem).'</td><td>'.                  &mt($parmitem).'</td><td>'.
               ($part?&mt('Part: [_1]',$part):&mt('All Parts')).'</td><td>';                  ($part?&mt('Part: [_1]',$part):&mt('All Parts')).'</td><td>';
         my $stillactive=0;              my $stillactive=0;
         if ($parmlog{$id}{'delflag'}) {              if ($parmlog{$id}{'delflag'}) {
         $output .= &mt('Deleted');                  $output .= &mt('Deleted');
         } else {              } else {
         if ($typeflag) {                  if ($typeflag) {
                     my $parmitem = &standard_parameter_names($value);                       my $parmitem = &standard_parameter_names($value); 
                     $parmitem = &mt($parmitem);                      $parmitem = &mt($parmitem);
             $output .= &mt('Type: [_1]',$parmitem);                      $output .= &mt('Type: [_1]',$parmitem);
         } else {                  } else {
             my ($level,@all)=&parmval_by_symb($what,$middle,&Apache::lonnet::metadata($middle,$what),                      my ($level,@all)=&parmval_by_symb($what,$middle,
                               $uname,$udom,$issection,$issection,$courseopt);                          &Apache::lonnet::metadata($middle,$what),
                           $uname,$udom,$issection,$issection,$courseopt);
                     my $showvalue = $value;                      my $showvalue = $value;
                     if ($istype{$parmname} eq '') {                      if ($istype{$parmname} eq '') {
                         my $type = &standard_parameter_types($parmname);                          my $type = &standard_parameter_types($parmname);
Line 5442  sub parm_change_log { Line 6609  sub parm_change_log {
                             }                              }
                         }                          }
                     } else {                      } else {
                 if (&isdateparm($istype{$parmname})) {                          if (&isdateparm($istype{$parmname})) {
                 $showvalue =                               $showvalue = &Apache::lonlocal::locallocaltime($value);
                                 &Apache::lonlocal::locallocaltime($value);                          }
                 }  
                     }                      }
                     $output .= $showvalue;                      $output .= $showvalue;
             if ($value ne $all[$level]) {                      if ($value ne $all[$level]) {
             $output .= '<br /><span class="LC_warning">'.&mt('Not active anymore').'</span>';                          $output .= '<br /><span class="LC_warning">'.&mt('Not active anymore').'</span>';
             } else {                      } else {
             $stillactive=1;                          $stillactive=1;
                       }
                   }
             }              }
               $output .= '</td>';
   
               unless ($readonly) { 
                   $output .= '<td>';
                   if ($stillactive) {
                       my $parmitem = &standard_parameter_names($parmname);
                       $parmitem = &mt($parmitem);
                       my $title=&mt('Changed [_1]',$parmitem);
                       my $description=&mt('Changed [_1] for [_2] to [_3]',
                           $parmitem,$realmdescription,
                           (&isdateparm($istype{$parmname})?&Apache::lonlocal::locallocaltime($value):$value));
                       if (($uname) && ($udom)) {
                           $output .=
                           &Apache::loncommon::messagewrapper('Notify User',
                                                              $uname,$udom,$title,
                                                              $description);
                       } else {
                           $output .=
                               &Apache::lonrss::course_blog_link($id,$title,
                                                                 $description);
                       }
                   }
                   $output .= '</td>';
               }
               $output .= &Apache::loncommon::end_data_table_row();
         }          }
         }  
         $output .= '</td><td>';  
               
         if ($stillactive) {  
                 my $parmitem = &standard_parameter_names($parmname);  
                 $parmitem = &mt($parmitem);  
         my $title=&mt('Changed [_1]',$parmitem);  
                 my $description=&mt('Changed [_1] for [_2] to [_3]',  
                                     $parmitem,$realmdescription,  
                     (&isdateparm($istype{$parmname})?&Apache::lonlocal::locallocaltime($value):$value));  
         if (($uname) && ($udom)) {  
             $output .=  
             &Apache::loncommon::messagewrapper('Notify User',  
                                $uname,$udom,$title,  
                                $description);  
         } else {  
             $output .=  
             &Apache::lonrss::course_blog_link($id,$title,  
                               $description);  
         }  
         }  
         $output .= '</td>'.&Apache::loncommon::end_data_table_row();  
     }  
         if ($env{'form.displayfilter'} eq 'containing') {          if ($env{'form.displayfilter'} eq 'containing') {
         my $wholeentry=$about_me_link.':'.              my $wholeentry=$about_me_link.':'.
         $parmlog{$id}{'exe_uname'}.':'.$parmlog{$id}{'exe_udom'}.':'.              $parmlog{$id}{'exe_uname'}.':'.$parmlog{$id}{'exe_udom'}.':'.
         $output;              $output;
         if ($wholeentry!~/\Q$env{'form.containingphrase'}\E/i) { next; }              if ($wholeentry!~/\Q$env{'form.containingphrase'}\E/i) { next; }
     }          }
         if ($count) {          if ($count) {
         $r->print($row_start.'<td rowspan="'.$count.'">'.$time.'</td>              $r->print($row_start.'<td rowspan="'.$count.'">'.$time.'</td>
                        <td rowspan="'.$count.'">'.$about_me_link.                          <td rowspan="'.$count.'">'.$about_me_link.
           '<br /><tt>'.$parmlog{$id}{'exe_uname'}.              '<br /><tt>'.$parmlog{$id}{'exe_uname'}.
                       ':'.$parmlog{$id}{'exe_udom'}.'</tt>'.                          ':'.$parmlog{$id}{'exe_udom'}.'</tt>'.
           $send_msg_link.'</td>'.$output);              $send_msg_link.'</td>'.$output);
         $shown++;              $shown++;
     }          }
     if (!($env{'form.show'} eq &mt('all')          if (!($env{'form.show'} eq &mt('all')
           || $shown<=$env{'form.show'})) { last; }              || $shown<=$env{'form.show'})) { last; }
     }      }
     $r->print(&Apache::loncommon::end_data_table());      $r->print(&Apache::loncommon::end_data_table());
     &endSettingsScreen($r);      &endSettingsScreen($r);
     $r->print(&Apache::loncommon::end_page());      $r->print(&Apache::loncommon::end_page());
 }  }
   
   ##################################################
   # MISC !
   ##################################################
   
   # Stores slot information.
   # Used by table UI
   # FIXME: I don't understand how this can work when the symb is not defined (if only a map was selected)
   #
   # @param {string} $slot_name - slot name
   # @param {string} $cdom - course domain
   # @param {string} $cnum - course number
   # @param {string} $symb - resource symb
   # @param {string} $uname - user name
   # @param {string} $udom - user domain
   # @returns {string} - 'ok' or error name
 sub update_slots {  sub update_slots {
     my ($slot_name,$cdom,$cnum,$symb,$uname,$udom) = @_;      my ($slot_name,$cdom,$cnum,$symb,$uname,$udom) = @_;
     my %slot=&Apache::lonnet::get_slot($slot_name);      my %slot=&Apache::lonnet::get_slot($slot_name);
Line 5552  sub update_slots { Line 6737  sub update_slots {
     return $success;      return $success;
 }  }
   
   # Deletes a slot reservation.
   # Used by table UI
   # FIXME: I don't understand how this can work when the symb is not defined (if only a map was selected)
   #
   # @param {string} $slot_name - slot name
   # @param {string} $cdom - course domain
   # @param {string} $cnum - course number
   # @param {string} $uname - user name
   # @param {string} $udom - user domain
   # @param {string} $symb - resource symb
   # @returns {string} - 'ok' or error name
 sub delete_slots {  sub delete_slots {
     my ($slot_name,$cdom,$cnum,$uname,$udom,$symb) = @_;      my ($slot_name,$cdom,$cnum,$uname,$udom,$symb) = @_;
     my $delresult;      my $delresult;
Line 5587  sub delete_slots { Line 6783  sub delete_slots {
     return $delresult;      return $delresult;
 }  }
   
   # Returns true if there is a current course.
   # Used by handler
   #
   # @returns {boolean}
 sub check_for_course_info {  sub check_for_course_info {
     my $navmap = Apache::lonnavmaps::navmap->new();      my $navmap = Apache::lonnavmaps::navmap->new();
     return 1 if ($navmap);      return 1 if ($navmap);
     return 0;      return 0;
 }  }
   
   # Returns the current course host and host LON-CAPA version.
   #
   # @returns {Array} - (course hostname, major version number, minor version number)
 sub parameter_release_vars {   sub parameter_release_vars { 
    my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};     my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
    my $chome = $env{'course.'.$env{'request.course.id'}.'.home'};     my $chome = $env{'course.'.$env{'request.course.id'}.'.home'};
Line 5602  sub parameter_release_vars { Line 6805  sub parameter_release_vars {
    return ($chostname,$cmajor,$cminor);     return ($chostname,$cmajor,$cminor);
 }  }
   
   # Checks if the course host version can handle a parameter required version,
   # and if it does, stores the release needed for the course.
   #
   # @param {string} $name - parameter name
   # @param {string} $value - parameter value
   # @param {string} $valmatch - name of the test used for checking the value
   # @param {string} $namematch - name of the test used for checking the name
   # @param {string} $needsrelease - version needed by the parameter, major.minor
   # @param {integer} $cmajor - course major version number
   # @param {integer} $cminor - course minor version number
   # @returns {boolean} - true if a newer version is needed
 sub parameter_releasecheck {  sub parameter_releasecheck {
     my ($name,$value,$valmatch,$namematch,$needsrelease,$cmajor,$cminor) = @_;      my ($name,$value,$valmatch,$namematch,$needsrelease,$cmajor,$cminor) = @_;
     my $needsnewer;      my $needsnewer;
Line 5621  sub parameter_releasecheck { Line 6835  sub parameter_releasecheck {
     return $needsnewer;      return $needsnewer;
 }  }
   
   sub get_permission {
       my %permission;
       my $allowed = 0;
       return (\%permission,$allowed) unless ($env{'request.course.id'});
       if ((&Apache::lonnet::allowed('opa',$env{'request.course.id'})) ||
           (&Apache::lonnet::allowed('opa',$env{'request.course.id'}.'/'.
                     $env{'request.course.sec'}))) {
           %permission= (
                          'edit'               => 1,
                          'set'                => 1,
                          'setoverview'        => 1,
                          'addmetadata'        => 1,
                          'ordermetadata'      => 1,
                          'setrestrictmeta'    => 1,
                          'newoverview'        => 1,
                          'setdefaults'        => 1,
                          'settable'           => 1,
                          'parameterchangelog' => 1,
                          'cleanparameters'    => 1,
                          'dateshift1'         => 1,
                          'dateshift2'         => 1,
                          'helper'             => 1,
            );
       } elsif ((&Apache::lonnet::allowed('vpa',$env{'request.course.id'})) ||
                (&Apache::lonnet::allowed('vpa',$env{'request.course.id'}.'/'.
                     $env{'request.course.sec'}))) {
           %permission = (
                          'set'                => 1,
                          'settable'           => 1,
                          'newoverview'        => 1,
                          'setoverview'        => 1,
                          'parameterchangelog' => 1,
                         );
       }
       foreach my $perm (values(%permission)) {
           if ($perm) { $allowed=1; last; }
       }
       return (\%permission,$allowed);
   }
   
   ##################################################
   # HANDLER
   ##################################################
   
   # Main handler for lonparmset.
   # Sub called based on request parameters action and command:
   # no command or action: print_main_menu
   # command 'set': assessparms (direct access to table mode for a resource)
   #                (this can also be accessed simply with the symb parameter)
   # action 'setoverview': overview (display all existing parameter settings)
   # action 'addmetadata': addmetafield (called to add a portfolio metadata field)
   # action 'ordermetadata': order_meta_fields (called to order portfolio metadata fields)
   # action 'setrestrictmeta': setrestrictmeta (display or save portfolio metadata)
   # action 'newoverview': newoverview (overview mode)
   # action 'setdefaults': defaultsetter (UI to change parameter setting default actions)
   # action 'settable': assessparms (table mode)
   # action 'parameterchangelog': parm_change_log (display log for parameter changes,
   #                              blog postings, user notification changes)
   # action 'cleanparameters': clean_parameters (unused)
   # action 'dateshift1': date_shift_one (overview mode, shift all dates)
   # action 'dateshift2': date_shift_two (overview mode, shift all dates)
 sub handler {  sub handler {
     my $r=shift;      my $r=shift;
   
Line 5648  sub handler { Line 6923  sub handler {
                                             'Parameter_Manager,Course_Environment,Parameter_Helper,Parameter_Overview,Table_Mode'});                                              'Parameter_Manager,Course_Environment,Parameter_Helper,Parameter_Overview,Table_Mode'});
   
 # ----------------------------------------------------- Needs to be in a course  # ----------------------------------------------------- Needs to be in a course
     my $parm_permission =      my ($parm_permission,$allowed) = &get_permission();
     (&Apache::lonnet::allowed('opa',$env{'request.course.id'}) ||  
      &Apache::lonnet::allowed('opa',$env{'request.course.id'}.'/'.  
                   $env{'request.course.sec'}));  
     my $exists = &check_for_course_info();      my $exists = &check_for_course_info();
   
     if ($env{'request.course.id'} &&  $parm_permission && $exists) {      if ($env{'request.course.id'} && $allowed && $exists) {
         #          #
         # Main switch on form.action and form.state, as appropriate          # Main switch on form.action and form.state, as appropriate
         #          #
         # Check first if coming from someone else headed directly for          # Check first if coming from someone else headed directly for
         #  the table mode          #  the table mode
         if ((($env{'form.command'} eq 'set') && ($env{'form.url'})          if (($parm_permission->{'set'}) && 
          && (!$env{'form.dis'})) || ($env{'form.symb'})) {              ((($env{'form.command'} eq 'set') && ($env{'form.url'})
         &assessparms($r);                  && (!$env{'form.dis'})) || ($env{'form.symb'}))) {
               &assessparms($r,$parm_permission);
         } elsif (! exists($env{'form.action'})) {          } elsif (! exists($env{'form.action'})) {
             &print_main_menu($r,$parm_permission);              &print_main_menu($r,$parm_permission);
           } elsif (!$parm_permission->{$env{'form.action'}}) {
               &print_main_menu($r,$parm_permission);
         } elsif ($env{'form.action'} eq 'setoverview') {          } elsif ($env{'form.action'} eq 'setoverview') {
         &overview($r);              &overview($r,$parm_permission);
     } elsif ($env{'form.action'} eq 'addmetadata') {          } elsif ($env{'form.action'} eq 'addmetadata') {
         &addmetafield($r);              &addmetafield($r);
     } elsif ($env{'form.action'} eq 'ordermetadata') {          } elsif ($env{'form.action'} eq 'ordermetadata') {
         &order_meta_fields($r);              &order_meta_fields($r);
         } elsif ($env{'form.action'} eq 'setrestrictmeta') {          } elsif ($env{'form.action'} eq 'setrestrictmeta') {
         &setrestrictmeta($r);              &setrestrictmeta($r);
         } elsif ($env{'form.action'} eq 'newoverview') {          } elsif ($env{'form.action'} eq 'newoverview') {
         &newoverview($r);              &newoverview($r,$parm_permission);
         } elsif ($env{'form.action'} eq 'setdefaults') {          } elsif ($env{'form.action'} eq 'setdefaults') {
         &defaultsetter($r);              &defaultsetter($r);
     } elsif ($env{'form.action'} eq 'settable') {          } elsif ($env{'form.action'} eq 'settable') {
         &assessparms($r);              &assessparms($r,$parm_permission);
         } elsif ($env{'form.action'} eq 'parameterchangelog') {          } elsif ($env{'form.action'} eq 'parameterchangelog') {
         &parm_change_log($r);              &parm_change_log($r,$parm_permission);
         } elsif ($env{'form.action'} eq 'cleanparameters') {          } elsif ($env{'form.action'} eq 'cleanparameters') {
         &clean_parameters($r);              &clean_parameters($r);
         } elsif ($env{'form.action'} eq 'dateshift1') {          } elsif ($env{'form.action'} eq 'dateshift1') {
             &date_shift_one($r);              &date_shift_one($r);
         } elsif ($env{'form.action'} eq 'dateshift2') {          } elsif ($env{'form.action'} eq 'dateshift2') {
Line 5690  sub handler { Line 6965  sub handler {
         }          }
     } else {      } else {
 # ----------------------------- Not in a course, or not allowed to modify parms  # ----------------------------- Not in a course, or not allowed to modify parms
     if ($exists) {          if ($exists) {
         $env{'user.error.msg'}=              $env{'user.error.msg'}=
         "/adm/parmset:opa:0:0:Cannot modify assessment parameters";              "/adm/parmset:opa:0:0:Cannot modify assessment parameters";
     } else {          } else {
         $env{'user.error.msg'}=              $env{'user.error.msg'}=
         "/adm/parmset::0:1:Course environment gone, reinitialize the course";              "/adm/parmset::0:1:Course environment gone, reinitialize the course";
     }          }
     return HTTP_NOT_ACCEPTABLE;          return HTTP_NOT_ACCEPTABLE;
     }      }
     &reset_caches();      &reset_caches();
   
Removed from v.1.558  
changed lines
  Added in v.1.583

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