Return to newslot.helper CVS log

Up to [LON-CAPA] / loncom / html / adm / helper

- For 2.11.2 (modified)
  Include changes in 1.35

    1: <helper title="Slot Creation" requiredpriv="mgq">
    2:   <state name="START" title="Specify Required Attributes"
    3:          help="Slot_RequiredAttributes">
    4: 
    5:     <nextstate>OPTIONAL</nextstate>
    6: 
    7:     <exec>
    8:       if (!exists($helper->{'VARS'}{'name'}) ||
    9: 	  $helper->{'VARS'}{'name'} !~ /\S/) {
   10: 	  &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'});
   11: 	  if (exists($env{'form.name'}) ||
   12: 	      $env{'form.name'} =~ /\S/) {
   13: 	      $helper->{'VARS'}{'name'}=$env{'form.name'};
   14: 	      $helper->{VARS}{'origname'}=$env{'form.name'};
   15: 	      $helper->{DATA}{copy} = 1;
   16: 	  }
   17:       }
   18:       $helper->{DATA}{origslot} = sub {
   19: 	  my ($which,$default)=@_;
   20: 	  if (!exists($helper->{'VARS'}{'name'}) ||
   21: 	      $helper->{'VARS'}{'name'} !~ /\S/) {
   22: 	      return $default;
   23: 	  }
   24: 	  my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
   25: 	  my $cdom  = $env{'course.'.$env{'request.course.id'}.'.domain'};
   26: 	  my $name=$helper->{VARS}{'origname'};
   27: 	  my %slot=&Apache::lonnet::get('slots', [$name], $cdom, $cnum);
   28: 	  if (!ref($slot{$name})) { return $default; }
   29:           if (($which eq 'ipdeny') || ($which eq 'ipallow')) {
   30:               if (!exists($slot{$name}{'ip'})) { return $default; }
   31:           } else {
   32:               if (!exists($slot{$name}{$which})) { return $default; }
   33:           }
   34:           if (($which eq 'ipdeny') || ($which eq 'ipallow')) {
   35:               my @allows;
   36:               my @denies;
   37:               foreach my $item (split(',',$slot{$name}{'ip'})) {
   38:                   $item =~ s/^\s*//;
   39:                   $item =~ s/\s*$//;
   40:                   if ($item =~ /^\!(.+)$/) {
   41:                       push(@denies,$1);
   42:                   } else {
   43:                       push(@allows,$item);
   44:                   }
   45:               }
   46:               if ($which eq 'ipdeny') {
   47:                   return join(',',@denies);
   48:               }
   49:               if ($which eq 'ipallow') {
   50:                   return join(',',@allows);
   51:               }
   52:           } else {
   53:               return $slot{$name}{$which};
   54:           }
   55:       }
   56:     </exec>
   57:     <message>
   58:         <br />Name: <br />&nbsp;&nbsp;&nbsp;
   59:     </message>
   60:     <string variable="name" size="30">
   61:       <validator>
   62:           if ($val=~/^\s*$/) { return 'Must specify a name'; }
   63:           if ($val=~/\s/) { return 'Must not contain spaces'; }
   64:           if ($val=~/\W/) { return 'Must contain only letters, numbers and _'; }
   65:           return undef;
   66:       </validator>
   67:       <defaultvalue>
   68:         return $helper->{'VARS'}{'name'};
   69:       </defaultvalue>
   70:     </string>
   71:     <condition>
   72:       <clause>$helper->{DATA}{copy}</clause>
   73:       <message>
   74: 	<p>Changing the Name will create a new slot with the new name, and not rename the existing slot.</p>
   75:       </message>
   76:     </condition>
   77:     <message>
   78:       <br />Start time:<br />&nbsp;&nbsp;&nbsp;
   79:     </message>
   80:     <date variable="starttime" hoursminutes="1">
   81:       <defaultvalue>
   82:         return &{$helper->{DATA}{origslot}}('starttime');
   83:       </defaultvalue>
   84:     </date>
   85:     <message>
   86:       <br />End time:<br />&nbsp;&nbsp;&nbsp;
   87:     </message>
   88:     <date variable="endtime" hoursminutes="1">
   89:       <defaultvalue>
   90:         return &{$helper->{DATA}{origslot}}('endtime');
   91:       </defaultvalue>
   92:       <validator>
   93:          if ($val < $helper->{'VARS'}{'starttime'}) {
   94: 	     return 'End time must be later than the start time.';
   95:          }
   96: 	 return undef;
   97:       </validator>
   98:     </date>
   99:     <message>
  100:       <br />Type:
  101:     </message>
  102:     <choices variable="type">
  103:       <choice computer='preassigned'>Instructor assignable.</choice>
  104:       <choice computer='schedulable_student'>Student selectable.</choice>
  105:       <defaultvalue>
  106:         return &{$helper->{DATA}{origslot}}('type','preassigned');
  107:       </defaultvalue>
  108:     </choices>
  109:   </state>
  110: 
  111: 
  112:   <state name="OPTIONAL" title="Specify Optional Attributes"
  113: 	 help="Slot_OptionalAttributes">
  114:     <message>
  115:         <p>Description:<br />&nbsp;&nbsp;&nbsp;
  116:     </message>
  117:     <string variable="description" size="60">
  118:       <defaultvalue>
  119:         return &{$helper->{DATA}{origslot}}('description');
  120:       </defaultvalue>
  121:     </string>
  122:     <condition>
  123:       <clause>$helper->{'VARS'}{'type'} eq 'schedulable_student'</clause>
  124:       <message>
  125:         </p><p>Time students can start reserving:<br />&nbsp;&nbsp;&nbsp;
  126:       </message>
  127:       <date variable="startreserve" hoursminutes="1" anytime="1">
  128:         <defaultvalue>
  129:           return &{$helper->{DATA}{origslot}}('startreserve','anytime');
  130:         </defaultvalue>
  131:         <validator>
  132:            if (defined($val) && $val > $helper->{'VARS'}{'starttime'}) {
  133: 	       return 'Reservation time must come before the slot has started.';
  134:            }
  135: 	   return undef;
  136:         </validator>
  137:       </date>
  138:       <message>
  139:         </p><p>Time students can no longer reserve:<br />&nbsp;&nbsp;&nbsp;
  140:       </message>
  141:       <date variable="endreserve" hoursminutes="1" anytime="1">
  142:         <defaultvalue>
  143:           return &{$helper->{DATA}{origslot}}('endreserve','anytime');
  144:         </defaultvalue>
  145:         <validator>
  146:            if (defined($val) && $val > $helper->{'VARS'}{'starttime'}) {
  147:                return 'Reservation end time must come before the slot has started.';
  148:            }
  149:            return undef;
  150:         </validator>
  151:       </date>
  152:       <message>
  153:          </p><p>Maximum number of students allowed in this slot:<br />&nbsp;&nbsp;&nbsp;
  154:       </message>
  155:       <string variable="maxspace" size="4">
  156:         <validator>
  157:             if ($val ne '' && $val=~/\D/) { return 'Must be numeric.'; }
  158:             return undef;
  159:         </validator>
  160:         <defaultvalue>
  161:           return &{$helper->{DATA}{origslot}}('maxspace');
  162:         </defaultvalue>
  163:       </string>
  164:       <message>
  165:          </p><p>Period of time when this slot can only be uniquely chosen:<br />&nbsp;&nbsp;&nbsp;Start:
  166:       </message>
  167:       <date variable="startunique" hoursminutes="1" anytime="1">
  168:         <defaultvalue>
  169:           my $default=&{$helper->{DATA}{origslot}}('uniqueperiod','anytime');
  170:           if ($default eq 'anytime') { return 'anytime' };
  171:           if (ref($default)) { return $default->[0]; }
  172:           return 'anytime';
  173:         </defaultvalue>
  174:       </date>
  175:       <message><br />&nbsp;&nbsp;&nbsp;End: </message>
  176:       <date variable="endunique" hoursminutes="1" anytime="1">
  177:         <defaultvalue>
  178:           my $default=&{$helper->{DATA}{origslot}}('uniqueperiod','anytime');
  179:           if ($default eq 'anytime') { return 'anytime' };
  180:           if (ref($default)) { return $default->[1]; }
  181:           return 'anytime';
  182:         </defaultvalue>
  183:         <validator>
  184:            if (defined($val) && $val < $helper->{'VARS'}{'startunique'}) {
  185: 	       return 'End time must be later than the start time.';
  186:            }
  187: 	   return undef;
  188:         </validator>
  189:       </date>
  190:       <message>
  191:         </p><p>Message(s) triggered by reservation change by student 
  192:       </message>
  193:     <choices variable="reservationmsg">
  194:       <choice computer='only_student'>Sent to student</choice>
  195:       <choice computer='student_and_user_notes_screen'>Sent to student and added to user notes</choice>
  196:       <choice computer='none'>None sent and no record in user notes</choice>
  197:       <defaultvalue>
  198:         my $default=&{$helper->{DATA}{origslot}}('reservationmsg');
  199:         if ($default eq 'only_student') { return $default; }
  200:         if ($default eq 'student_and_user_notes_screen') { return $default; }
  201:         return 'none';
  202:       </defaultvalue>
  203:     </choices>
  204:     </condition>
  205:     <condition>
  206:       <clause>$helper->{'VARS'}{'type'} eq 'preassigned'</clause>
  207:       <exec>
  208:         delete($helper->{'VARS'}{'startreserve'});
  209:         delete($helper->{'VARS'}{'endreserve'});
  210:         delete($helper->{'VARS'}{'maxspace'});
  211:       </exec>
  212:       <message>
  213:          </p><p>Period of time when this slot can only be uniquely assigned:<br />&nbsp;&nbsp;&nbsp;Start:
  214:       </message>
  215:       <date variable="startunique" hoursminutes="1" anytime="1">
  216:         <defaultvalue>
  217:           my $default=&{$helper->{DATA}{origslot}}('uniqueperiod','anytime');
  218:           if ($default eq 'anytime') { return 'anytime' };
  219:           if (ref($default)) { return $default->[0]; }
  220:           return 'anytime';
  221:         </defaultvalue>
  222:       </date>
  223:       <message><br />&nbsp;&nbsp;&nbsp;End: </message>
  224:       <date variable="endunique" hoursminutes="1" anytime="1">
  225:         <defaultvalue>
  226:           my $default=&{$helper->{DATA}{origslot}}('uniqueperiod','anytime');
  227:           if ($default eq 'anytime') { return 'anytime' };
  228:           if (ref($default)) { return $default->[1]; }
  229:           return 'anytime';
  230:         </defaultvalue>
  231:         <validator>
  232:            if (defined($val) && $val < $helper->{'VARS'}{'startunique'}) {
  233:                return 'End time must be later than the start time.';
  234:            }
  235:            return undef;
  236:         </validator>
  237:       </date>
  238:     </condition>
  239:     <message>
  240:       </p><p>Proctored access:
  241:     </message>
  242:     <choices variable="useproctor">
  243:       <choice computer='no'>No proctor checkin required for access.</choice>
  244:       <choice computer='yes'>Require proctored checkin for access.</choice>
  245:       <defaultvalue>
  246:         my $default=&{$helper->{DATA}{origslot}}('proctor');
  247:         if ($default) { return 'yes'; }
  248:         return 'no';
  249:       </defaultvalue>
  250:     </choices>
  251: 
  252:     <message>
  253:       </p><p>Secret word proctors use to checkin users:<br />&nbsp;&nbsp;&nbsp;
  254:     </message>
  255:     <string variable="secret" size="12">
  256:       <validator>
  257:           return undef;
  258:       </validator>
  259:       <defaultvalue>
  260:         return &{$helper->{DATA}{origslot}}('secret');
  261:       </defaultvalue>
  262:     </string>
  263:     <message>
  264:       </p><p>Slot is:
  265:     </message>
  266:     <helpicon file="Slot_ChoosingResources" />
  267: 
  268:     <choices variable="restricttosymb">
  269:       <choice nextstate="PROCTOR" computer='any'>usable for any resource.</choice>
  270:       <choice nextstate="RESOURCESELECT" computer='resource'>restricted to a specific resource.</choice>
  271:       <defaultvalue>
  272:         my $default=&{$helper->{DATA}{origslot}}('symb');
  273:         if ($default) { return 'resource'; }
  274:         return 'any';
  275:       </defaultvalue>
  276:     </choices>
  277:     
  278:     <message>
  279: 	</p><p>IP restrictions -- allow from all except:<br />&nbsp;&nbsp;&nbsp;      
  280:     </message>
  281: 
  282:     <string variable="ipdeny" size="30">
  283:       <validator>
  284:           return undef;
  285:       </validator>
  286:       <defaultvalue>
  287:         return &{$helper->{DATA}{origslot}}('ipdeny');
  288:       </defaultvalue>
  289:     </string>
  290: 
  291:     <message>
  292:         </p><p>IP restrictions -- deny from all except: <br />&nbsp;&nbsp;&nbsp;
  293:     </message>
  294: 
  295:     <string variable="ipallow" size="30">
  296:       <validator>
  297:           return undef;
  298:       </validator>
  299:       <defaultvalue>
  300:         return &{$helper->{DATA}{origslot}}('ipallow');
  301:       </defaultvalue>
  302:     </string>
  303:     <message>  </p>  </message>
  304:   </state>
  305: 
  306: 
  307:   <state name="RESOURCESELECT" title="Specify Optional Attributes">
  308: 
  309:     <nextstate>PROCTOR</nextstate>
  310: 
  311:     <resource variable="symb">
  312:       <filterfunc>return $res->is_problem()</filterfunc>
  313:       <valuefunc>return $res->symb()</valuefunc>
  314:       <defaultvalue>
  315:         return &{$helper->{DATA}{origslot}}('symb');
  316:       </defaultvalue>
  317:     </resource>    
  318:   </state>
  319: 
  320: 
  321:   <state name="PROCTOR" title="Specify Proctors"
  322: 	 help="Slot_SpecifyProctors">
  323: 
  324:     <skip>
  325:       <clause>$helper->{'VARS'}{'useproctor'} eq 'no'</clause>
  326:       <nextstate>RESTRICTUSER</nextstate>
  327:     </skip>
  328: 
  329:     <nextstate>RESTRICTUSER</nextstate>
  330: 
  331:     <student variable="proctor" multichoice="1" coursepersonnel="1"
  332:              activeonly="1" emptyallowed="0">
  333:       <defaultvalue>
  334:         my @defaults;
  335:         my $default=&{$helper->{DATA}{origslot}}('proctor');
  336:         if ($default) {
  337: 	    @defaults=(split(',',$default)); 
  338: 	}
  339:         return @defaults;
  340:       </defaultvalue>
  341:     </student>
  342:   </state>
  343: 
  344: 
  345:   <state name="RESTRICTUSER" title="Restrict slot availability"
  346: 	 help="Slot_RestrictAvailibility">
  347:     <skip>
  348:        <clause>$helper->{'VARS'}{'type'} ne 'schedulable_student'</clause>
  349:        <nextstate>FINISH</nextstate>
  350:     </skip>
  351: 
  352:     <nextstate>FINISH</nextstate>
  353:     <message>
  354:       <p>Slots are by default available to all users in a course, if you would like this slot to be restricted to a subset of users you can specify restrictions.</p>
  355:     </message>
  356: 
  357:     <message>
  358:       Select sections to limit slot availability to: <br />&nbsp;&nbsp;&nbsp;
  359:     </message>
  360:     <section variable="allowedsections" multichoice="1" allowempty="1">
  361:       <defaultvalue>
  362:         return join('|||',
  363: 		    split(',',&{$helper->{DATA}{origslot}}('allowedsections')));
  364:       </defaultvalue>
  365:     </section>
  366:     <message>
  367:       Select users to limit slot availability to: <br />&nbsp;&nbsp;&nbsp;
  368:     </message>
  369:     <student variable="allowedusers" multichoice="1" coursepersonnel="1"
  370:              activeonly="1" emptyallowed="1">
  371:       <defaultvalue>
  372: 	 return split(',',&{$helper->{DATA}{origslot}}('allowedusers'));
  373:       </defaultvalue>
  374:     </student>
  375:   </state>
  376: 
  377: 
  378:   <state name="FINISH" title="Creating/Modifying Slot">
  379: 	    <message> Created Slot  </message>	
  380:     <final>
  381:       <finalcode>
  382:         my $result;
  383: 	if ($helper->{'STATE'} ne 'FINISH') { return; }
  384: 	my %slot;
  385: 
  386: 	foreach my $which ('type','starttime','endtime') {
  387: 	    $slot{$which} = $helper->{'VARS'}{$which};
  388: 	}
  389: 
  390: 	foreach my $which ('description','maxspace','secret','symb') {
  391: 	    if ( $helper->{'VARS'}{$which} =~/\S/ ) {
  392: 		$slot{$which} = $helper->{'VARS'}{$which};
  393: 	    }
  394: 	}
  395: 
  396:         if ($helper->{'VARS'}{'ipdeny'} =~/\S/ ) {
  397:             foreach my $item (split(',',$helper->{'VARS'}{'ipdeny'})) {
  398:                 $item =~ s/^\s*//;
  399:                 $item =~ s/\s*$//;
  400:                 $slot{'ip'} .= '!'.$item.',';
  401:             }
  402:         }
  403: 
  404:         if ($helper->{'VARS'}{'ipallow'} =~/\S/ ) {
  405:             foreach my $item (split(',',$helper->{'VARS'}{'ipallow'})) {
  406:                 $item =~ s/^\s*//;
  407:                 $item =~ s/\s*$//;
  408:                 $slot{'ip'} .= $item.',';
  409:             }
  410:         }
  411: 
  412:         if ($slot{'ip'} ne '') {
  413:             $slot{'ip'} =~s /,$//;
  414:         }
  415: 
  416:         if ($helper->{'VARS'}{'type'} eq 'schedulable_student') {
  417:             if (($helper->{'VARS'}{'reservationmsg'} eq 'only_student') ||
  418:                ($helper->{'VARS'}{'reservationmsg'} eq 'student_and_user_notes_screen')) {
  419:                 $slot{'reservationmsg'} = $helper->{'VARS'}{'reservationmsg'}; 
  420:             } else {
  421:                 $slot{'reservationmsg'} = 'none';
  422:             }
  423:         }
  424: 
  425: 	if ( $helper->{'VARS'}{'startreserve'} > 0) {
  426: 		$slot{'startreserve'} = $helper->{'VARS'}{'startreserve'};
  427: 	}
  428: 
  429:         if ( $helper->{'VARS'}{'endreserve'} > 0) {
  430:             $slot{'endreserve'} = $helper->{'VARS'}{'endreserve'};
  431:         }
  432: 
  433: 	if ( $helper->{'VARS'}{'startunique'} > 0 &&
  434: 	     $helper->{'VARS'}{'endunique'} > 0 ) {
  435: 	    $slot{'uniqueperiod'} = [$helper->{'VARS'}{'startunique'},
  436: 				     $helper->{'VARS'}{'endunique'}];
  437: 	}
  438: 
  439:         if ( $helper->{'VARS'}{'useproctor'} eq 'yes'
  440: 	     && $helper->{'VARS'}{'proctor'} =~/\S/ ) {
  441: 	    my @names;
  442: 	    # just need the username/domain throw away the other data 
  443:             # that <student> returns
  444: 	    foreach my $user (split(/\|\|\|/, $helper->{'VARS'}{'proctor'})) {
  445: 		my ($uname,$udomain)=split(/:/,$user);
  446: 		push(@names,"$uname:$udomain");
  447: 	    }
  448: 	    # make sure the usernmaes are unique
  449: 	    my %proctors = map { ($_,1) } @names;
  450: 	    $slot{'proctor'}=join(',',sort(keys(%proctors)));
  451: 	}
  452: 
  453:         if ( $helper->{'VARS'}{'allowedsections'} =~/\S/ ) {
  454: 	    $slot{'allowedsections'}=
  455: 		join(',',sort(split(/\|\|\|/,
  456: 				    $helper->{'VARS'}{'allowedsections'})));
  457: 	}
  458: 
  459:         if ( $helper->{'VARS'}{'allowedusers'} =~/\S/ ) {
  460: 	    my @names;
  461: 	    # just need the username/domain throw away the other data 
  462:             # that <student> returns
  463: 	    foreach my $item (split(/\|\|\|/,
  464: 				    $helper->{'VARS'}{'allowedusers'})) {
  465: 		my ($uname,$udomain)=split(/:/,$item);
  466: 		push(@names,"$uname:$udomain");
  467: 	    }
  468: 
  469: 	    # make sure the choices are unique
  470: 	    my %users = map { ($_,1) } @names;
  471: 	    $slot{'allowedusers'}=join(',',sort(keys(%users)));
  472: 	}
  473: 
  474:         my $cname = $env{'course.'.$env{'request.course.id'}.'.num'};
  475:         my $cdom  = $env{'course.'.$env{'request.course.id'}.'.domain'};
  476: 
  477:         my $ret = &Apache::lonnet::cput('slots',
  478: 					{$helper->{'VARS'}{'name'} => \%slot},
  479: 					$cdom,$cname);
  480:         if ($ret eq 'ok') {
  481:             &Apache::lonnet::devalidate_slots_cache($cname,$cdom);
  482:         }
  483:         $result.="\n ".'Name: '.&HTML::Entities::encode($helper->{'VARS'}{'name'}).'</li>'.
  484:     "\n".'<li> Starts: '.&Apache::lonlocal::locallocaltime($slot{'starttime'}).'</li>'.
  485:                  "\n".'<li> Ends: '.&Apache::lonlocal::locallocaltime($slot{'endtime'}).'</li>'.
  486:                  "\n".'<li> Type: '.$slot{'type'}.'</li>';
  487:         my %labels =
  488:              map {($_->[0],$_->[1])} &Apache::slotrequest::csvupload_fields();
  489:         foreach my $which ('ip','description','maxspace','secret','symb',
  490: 			   'allowedsections','allowedusers') {
  491: 	    if (exists($slot{$which})) {
  492: 		$result.="\n".'<li> '.$labels{$which}.': '.
  493: 		    &HTML::Entities::encode($slot{$which}).'</li>';
  494: 	    }
  495: 	}
  496: 	if (exists($slot{'startreserve'})) {
  497: 	    $result.="\n".'<li> '.$labels{'startreserve'}.': '.
  498: 		    &Apache::lonlocal::locallocaltime($slot{'startreserve'}).'</li>';
  499: 	}
  500: 
  501:         if (exists($slot{'endreserve'})) {
  502:             $result.="\n".'<li> '.$labels{'endreserve'}.': '.
  503:                     &Apache::lonlocal::locallocaltime($slot{'endreserve'}).'</li>';
  504:         }
  505: 
  506:         if (exists($slot{'reservationmsg'})) {
  507:             my %options = &Apache::slotrequest::slot_reservationmsg_options();
  508:             $result.="\n".'<li> '.$labels{'reservationmsg'}.': '.
  509:                           $options{$slot{'reservationmsg'}}.'</li>';
  510:         }
  511: 
  512:         if (exists($slot{'proctor'})) {
  513: 	    my $proctors = $slot{'proctor'};
  514: 	    $proctors =~ s/,/, /g;
  515: 	    $result.="\n".'<li> '.$labels{'proctor'}.': '.
  516: 		&HTML::Entities::encode($proctors).'</li>';
  517: 	}
  518:         if (exists($slot{'uniqueperiod'})) {
  519: 	    $result.=
  520:                  "\n".'<li> '.$labels{'uniqueperiod'}.': '.
  521: 		 &Apache::lonlocal::locallocaltime($slot{'uniqueperiod'}[0]).
  522: 		 ', '.
  523: 		 &Apache::lonlocal::locallocaltime($slot{'uniqueperiod'}[1]).
  524: 		 '</li>';
  525: 	}
  526:         return $result;
  527:       </finalcode>
  528:       <exitpage>/adm/slotrequest?command=showslots</exitpage>
  529:     </final>
  530:   </state>
  531: </helper>