Parent Directory
| 
Revision Log
Revision 1197 - (view) (download) (as text)
| 1 : | sh002i | 449 | ################################################################################ |
| 2 : | sh002i | 494 | # WeBWorK mod_perl (c) 2000-2002 WeBWorK Project |
| 3 : | sh002i | 449 | # $Id$ |
| 4 : | ################################################################################ | ||
| 5 : | |||
| 6 : | malsyned | 353 | package WeBWorK::ContentGenerator::Problem; |
| 7 : | sh002i | 818 | use base qw(WeBWorK::ContentGenerator); |
| 8 : | malsyned | 396 | |
| 9 : | sh002i | 455 | =head1 NAME |
| 10 : | gage | 1039 | |
| 11 : | sh002i | 455 | WeBWorK::ContentGenerator::Problem - Allow a student to interact with a problem. |
| 12 : | |||
| 13 : | =cut | ||
| 14 : | |||
| 15 : | malsyned | 396 | use strict; |
| 16 : | use warnings; | ||
| 17 : | sh002i | 449 | use CGI qw(); |
| 18 : | sh002i | 919 | use File::Path qw(rmtree); |
| 19 : | sh002i | 455 | use WeBWorK::Form; |
| 20 : | use WeBWorK::PG; | ||
| 21 : | sh002i | 623 | use WeBWorK::PG::IO; |
| 22 : | sh002i | 1147 | use WeBWorK::Utils qw(writeLog encodeAnswers decodeAnswers ref2string makeTempDirectory); |
| 23 : | gage | 997 | use WeBWorK::DB::Utils qw(global2user user2global findDefaults); |
| 24 : | gage | 1190 | use WeBWorK::Timing; |
| 25 : | sh002i | 449 | ############################################################ |
| 26 : | # | ||
| 27 : | sh002i | 424 | # user |
| 28 : | malsyned | 704 | # effectiveUser |
| 29 : | sh002i | 424 | # key |
| 30 : | sh002i | 415 | # |
| 31 : | sh002i | 424 | # displayMode |
| 32 : | # showOldAnswers | ||
| 33 : | # showCorrectAnswers | ||
| 34 : | # showHints | ||
| 35 : | # showSolutions | ||
| 36 : | sh002i | 415 | # |
| 37 : | sh002i | 425 | # AnSwEr# - answer blanks in problem |
| 38 : | # | ||
| 39 : | sh002i | 429 | # redisplay - name of the "Redisplay Problem" button |
| 40 : | # submitAnswers - name of "Submit Answers" button | ||
| 41 : | sh002i | 818 | # checkAnswers - name of the "Check Answers" button |
| 42 : | # previewAnswers - name of the "Preview Answers" button | ||
| 43 : | sh002i | 449 | # |
| 44 : | ############################################################ | ||
| 45 : | gage | 392 | |
| 46 : | sh002i | 476 | sub pre_header_initialize { |
| 47 : | sh002i | 424 | my ($self, $setName, $problemNumber) = @_; |
| 48 : | gage | 1038 | my $r = $self->{r}; |
| 49 : | my $courseEnv = $self->{ce}; | ||
| 50 : | my $db = $self->{db}; | ||
| 51 : | my $userName = $r->param('user'); | ||
| 52 : | my $effectiveUserName = $r->param('effectiveUser'); | ||
| 53 : | sh002i | 1197 | my $key = $r->param('key'); |
| 54 : | gage | 997 | my $user = $db->getUser($userName); |
| 55 : | my $effectiveUser = $db->getUser($effectiveUserName); | ||
| 56 : | sh002i | 1197 | my $permissionLevel = $db->getPermissionLevel($userName)->permission(); |
| 57 : | gage | 1007 | |
| 58 : | sh002i | 1197 | # obtain the merged set for $effectiveUser |
| 59 : | my $set = $db->getMergedSet($effectiveUserName, $setName); | ||
| 60 : | gage | 992 | |
| 61 : | sh002i | 1197 | # obtain the merged problem for $effectiveUser |
| 62 : | my $problem = $db->getMergedProblem($effectiveUserName, $setName, $problemNumber); | ||
| 63 : | gage | 993 | |
| 64 : | sh002i | 1197 | my $editMode = $r->param("editMode"); |
| 65 : | gage | 992 | |
| 66 : | sh002i | 1197 | if ($permissionLevel > 0 and defined $editMode) { |
| 67 : | # professors are allowed to fabricate sets and problems not | ||
| 68 : | # assigned to them (or anyone). this allows them to use the | ||
| 69 : | # editor to | ||
| 70 : | |||
| 71 : | # if that is not yet defined obtain the global set, convert | ||
| 72 : | # it to a user set, and add fake user data | ||
| 73 : | unless (defined $set) { | ||
| 74 : | my $userSetClass = $db->{set_user}->{record}; | ||
| 75 : | $set = global2user($userSetClass, | ||
| 76 : | $db->getGlobalSet($setName)); | ||
| 77 : | die "Set $setName does not exist" | ||
| 78 : | unless defined $set; | ||
| 79 : | $set->psvn(0); | ||
| 80 : | } | ||
| 81 : | |||
| 82 : | # if that is not yet defined obtain the global problem, | ||
| 83 : | # convert it to a user problem, and add fake user data | ||
| 84 : | unless (defined $problem) { | ||
| 85 : | my $userProblemClass = $db->{problem_user}->{record}; | ||
| 86 : | $problem = global2user($userProblemClass, | ||
| 87 : | $db->getGlobalProblem($setName,$problemNumber)); | ||
| 88 : | die "Problem $problemNumber in set $setName does not exist" | ||
| 89 : | unless defined $problem; | ||
| 90 : | $problem->user_id($effectiveUserName); | ||
| 91 : | $problem->problem_seed(0); | ||
| 92 : | $problem->status(0); | ||
| 93 : | $problem->attempted(0); | ||
| 94 : | $problem->last_answer(""); | ||
| 95 : | $problem->num_correct(0); | ||
| 96 : | $problem->num_incorrect(0); | ||
| 97 : | } | ||
| 98 : | |||
| 99 : | # now we're sure we have valid UserSet and UserProblem objects | ||
| 100 : | # yay! | ||
| 101 : | |||
| 102 : | # now deal with possible editor overrides: | ||
| 103 : | |||
| 104 : | # if the caller is asking to override the source file, and | ||
| 105 : | # editMode calls for a temporary file, do so | ||
| 106 : | my $sourceFilePath = $r->param("sourceFilePath"); | ||
| 107 : | if (defined $sourceFilePath and $editMode eq "temporaryFile") { | ||
| 108 : | $problem->source_file($sourceFilePath); | ||
| 109 : | } | ||
| 110 : | |||
| 111 : | # if the caller is asking to override the problem seed, do so | ||
| 112 : | my $problemSeed = $r->param("problemSeed"); | ||
| 113 : | if (defined $problemSeed) { | ||
| 114 : | $problem->problem_seed($problemSeed); | ||
| 115 : | } | ||
| 116 : | } else { | ||
| 117 : | # students can't view problems not assigned to them | ||
| 118 : | die "Set $setName is not assigned to $effectiveUserName" | ||
| 119 : | unless defined $set; | ||
| 120 : | die "Problem $problemNumber in set $setName is not assigned to $effectiveUserName" | ||
| 121 : | unless defined $problem; | ||
| 122 : | } | ||
| 123 : | gage | 992 | |
| 124 : | sh002i | 1197 | $self->{userName} = $userName; |
| 125 : | $self->{effectiveUserName} = $effectiveUserName; | ||
| 126 : | $self->{user} = $user; | ||
| 127 : | $self->{effectiveUser} = $effectiveUser; | ||
| 128 : | $self->{permissionLevel} = $permissionLevel; | ||
| 129 : | $self->{set} = $set; | ||
| 130 : | $self->{problem} = $problem; | ||
| 131 : | $self->{editMode} = $editMode; | ||
| 132 : | sh002i | 429 | |
| 133 : | ##### form processing ##### | ||
| 134 : | |||
| 135 : | sh002i | 425 | # set options from form fields (see comment at top of file for names) |
| 136 : | sh002i | 692 | my $displayMode = $r->param("displayMode") || $courseEnv->{pg}->{options}->{displayMode}; |
| 137 : | sh002i | 425 | my $redisplay = $r->param("redisplay"); |
| 138 : | sh002i | 429 | my $submitAnswers = $r->param("submitAnswers"); |
| 139 : | sh002i | 719 | my $checkAnswers = $r->param("checkAnswers"); |
| 140 : | sh002i | 623 | my $previewAnswers = $r->param("previewAnswers"); |
| 141 : | gage | 388 | |
| 142 : | gage | 926 | # fields which may be defined when using Problem Editor |
| 143 : | sh002i | 1197 | #my $override_seed = ($permissionLevel>=10) ? $r->param('problemSeed') : undef; |
| 144 : | #my $override_problem_source = ($permissionLevel>=10) ? $r->param('sourceFilePath') : undef; | ||
| 145 : | #my $editMode = undef; | ||
| 146 : | #my $submit_button = $r->param('submit_button'); | ||
| 147 : | #if ( defined($submit_button ) ) { | ||
| 148 : | # $editMode = "temporaryFile" if $submit_button eq 'Refresh'; | ||
| 149 : | # $editMode = 'savedFile' if $submit_button eq 'Save'; | ||
| 150 : | #} | ||
| 151 : | # | ||
| 152 : | ##override using the source file data from the form field | ||
| 153 : | #$problem->source_file($override_problem_source) if defined($override_problem_source); | ||
| 154 : | #$problem->problem_seed($override_seed) if defined($override_seed); | ||
| 155 : | # | ||
| 156 : | ## store path to source file for title. | ||
| 157 : | #$self->{problem_source_name} = $problem->source_file; | ||
| 158 : | #$self->{edit_mode} = $editMode; | ||
| 159 : | #$self->{current_problem_source} = (defined($override_problem_source) ) ? | ||
| 160 : | gage | 1007 | |
| 161 : | sh002i | 449 | # coerce form fields into CGI::Vars format |
| 162 : | my $formFields = { WeBWorK::Form->new_from_paramable($r)->Vars }; | ||
| 163 : | |||
| 164 : | sh002i | 738 | $self->{displayMode} = $displayMode; |
| 165 : | $self->{redisplay} = $redisplay; | ||
| 166 : | $self->{submitAnswers} = $submitAnswers; | ||
| 167 : | $self->{checkAnswers} = $checkAnswers; | ||
| 168 : | $self->{previewAnswers} = $previewAnswers; | ||
| 169 : | $self->{formFields} = $formFields; | ||
| 170 : | |||
| 171 : | sh002i | 449 | ##### permissions ##### |
| 172 : | |||
| 173 : | sh002i | 738 | # are we allowed to view this problem? |
| 174 : | $self->{isOpen} = time >= $set->open_date || $permissionLevel > 0; | ||
| 175 : | return unless $self->{isOpen}; | ||
| 176 : | |||
| 177 : | sh002i | 449 | # what does the user want to do? |
| 178 : | sh002i | 431 | my %want = ( |
| 179 : | showOldAnswers => $r->param("showOldAnswers") || $courseEnv->{pg}->{options}->{showOldAnswers}, | ||
| 180 : | showCorrectAnswers => $r->param("showCorrectAnswers") || $courseEnv->{pg}->{options}->{showCorrectAnswers}, | ||
| 181 : | showHints => $r->param("showHints") || $courseEnv->{pg}->{options}->{showHints}, | ||
| 182 : | showSolutions => $r->param("showSolutions") || $courseEnv->{pg}->{options}->{showSolutions}, | ||
| 183 : | sh002i | 719 | recordAnswers => $submitAnswers, |
| 184 : | sh002i | 747 | checkAnswers => $checkAnswers, |
| 185 : | sh002i | 431 | ); |
| 186 : | sh002i | 429 | |
| 187 : | sh002i | 431 | # are certain options enforced? |
| 188 : | my %must = ( | ||
| 189 : | showOldAnswers => 0, | ||
| 190 : | showCorrectAnswers => 0, | ||
| 191 : | showHints => 0, | ||
| 192 : | showSolutions => 0, | ||
| 193 : | recordAnswers => mustRecordAnswers($permissionLevel), | ||
| 194 : | sh002i | 747 | checkAnswers => 0, |
| 195 : | sh002i | 431 | ); |
| 196 : | |||
| 197 : | sh002i | 429 | # does the user have permission to use certain options? |
| 198 : | sh002i | 431 | my %can = ( |
| 199 : | showOldAnswers => 1, | ||
| 200 : | showCorrectAnswers => canShowCorrectAnswers($permissionLevel, $set->answer_date), | ||
| 201 : | showHints => 1, | ||
| 202 : | showSolutions => canShowSolutions($permissionLevel, $set->answer_date), | ||
| 203 : | recordAnswers => canRecordAnswers($permissionLevel, $set->open_date, $set->due_date, | ||
| 204 : | $problem->max_attempts, $problem->num_correct + $problem->num_incorrect + 1), | ||
| 205 : | sh002i | 756 | # attempts=num_correct+num_incorrect+1, as this happens before updating $problem |
| 206 : | checkAnswers => canCheckAnswers($permissionLevel, $set->answer_date), | ||
| 207 : | sh002i | 431 | ); |
| 208 : | sh002i | 429 | |
| 209 : | # final values for options | ||
| 210 : | sh002i | 431 | my %will; |
| 211 : | sh002i | 617 | foreach (keys %must) { |
| 212 : | sh002i | 431 | $will{$_} = $can{$_} && ($want{$_} || $must{$_}); |
| 213 : | } | ||
| 214 : | sh002i | 429 | |
| 215 : | ##### sticky answers ##### | ||
| 216 : | |||
| 217 : | sh002i | 431 | if (not $submitAnswers and $will{showOldAnswers}) { |
| 218 : | # do this only if new answers are NOT being submitted | ||
| 219 : | sh002i | 429 | my %oldAnswers = decodeAnswers($problem->last_answer); |
| 220 : | $formFields->{$_} = $oldAnswers{$_} foreach keys %oldAnswers; | ||
| 221 : | } | ||
| 222 : | |||
| 223 : | ##### translation ##### | ||
| 224 : | |||
| 225 : | sh002i | 424 | my $pg = WeBWorK::PG->new( |
| 226 : | $courseEnv, | ||
| 227 : | malsyned | 704 | $effectiveUser, |
| 228 : | gage | 1038 | $key, |
| 229 : | sh002i | 502 | $set, |
| 230 : | $problem, | ||
| 231 : | sh002i | 1197 | $set->psvn, # FIXME: this field should be removed |
| 232 : | sh002i | 502 | $formFields, |
| 233 : | sh002i | 424 | { # translation options |
| 234 : | sh002i | 434 | displayMode => $displayMode, |
| 235 : | showHints => $will{showHints}, | ||
| 236 : | showSolutions => $will{showSolutions}, | ||
| 237 : | refreshMath2img => $will{showHints} || $will{showSolutions}, | ||
| 238 : | sh002i | 684 | processAnswers => 1, |
| 239 : | sh002i | 424 | }, |
| 240 : | ); | ||
| 241 : | gage | 392 | |
| 242 : | sh002i | 684 | ##### fix hint/solution options ##### |
| 243 : | |||
| 244 : | $can{showHints} &&= $pg->{flags}->{hintExists}; | ||
| 245 : | $can{showSolutions} &&= $pg->{flags}->{solutionExists}; | ||
| 246 : | |||
| 247 : | sh002i | 449 | ##### store fields ##### |
| 248 : | |||
| 249 : | $self->{want} = \%want; | ||
| 250 : | $self->{must} = \%must; | ||
| 251 : | $self->{can} = \%can; | ||
| 252 : | $self->{will} = \%will; | ||
| 253 : | |||
| 254 : | $self->{pg} = $pg; | ||
| 255 : | } | ||
| 256 : | |||
| 257 : | sh002i | 1131 | #sub if_warnings($$) { |
| 258 : | # my ($self, $arg) = @_; | ||
| 259 : | # return 0 unless $self->{isOpen}; | ||
| 260 : | # return $self->{pg}->{warnings} ne ""; | ||
| 261 : | #} | ||
| 262 : | sh002i | 558 | |
| 263 : | sub if_errors($$) { | ||
| 264 : | my ($self, $arg) = @_; | ||
| 265 : | sh002i | 738 | return 0 unless $self->{isOpen}; |
| 266 : | sh002i | 558 | return $self->{pg}->{flags}->{error_flag}; |
| 267 : | } | ||
| 268 : | |||
| 269 : | sh002i | 562 | sub head { |
| 270 : | sh002i | 555 | my $self = shift; |
| 271 : | sh002i | 738 | return "" unless $self->{isOpen}; |
| 272 : | sh002i | 555 | return $self->{pg}->{head_text} if $self->{pg}->{head_text}; |
| 273 : | } | ||
| 274 : | sh002i | 476 | |
| 275 : | sh002i | 1131 | sub options { |
| 276 : | my $self = shift; | ||
| 277 : | return join("", | ||
| 278 : | CGI::start_form("POST", $self->{r}->uri), | ||
| 279 : | $self->hidden_authen_fields, | ||
| 280 : | CGI::hr(), | ||
| 281 : | CGI::start_div({class=>"viewOptions"}), | ||
| 282 : | $self->viewOptions(), | ||
| 283 : | CGI::end_div(), | ||
| 284 : | CGI::end_form() | ||
| 285 : | ); | ||
| 286 : | } | ||
| 287 : | |||
| 288 : | sh002i | 476 | sub path { |
| 289 : | my $self = shift; | ||
| 290 : | my $args = $_[-1]; | ||
| 291 : | sh002i | 818 | my $setName = $self->{set}->set_id; |
| 292 : | my $problemNumber = $self->{problem}->problem_id; | ||
| 293 : | sh002i | 476 | |
| 294 : | sh002i | 809 | my $ce = $self->{ce}; |
| 295 : | sh002i | 476 | my $root = $ce->{webworkURLs}->{root}; |
| 296 : | my $courseName = $ce->{courseName}; | ||
| 297 : | return $self->pathMacro($args, | ||
| 298 : | "Home" => "$root", | ||
| 299 : | $courseName => "$root/$courseName", | ||
| 300 : | sh002i | 555 | $setName => "$root/$courseName/$setName", |
| 301 : | sh002i | 476 | "Problem $problemNumber" => "", |
| 302 : | ); | ||
| 303 : | } | ||
| 304 : | |||
| 305 : | sub siblings { | ||
| 306 : | my $self = shift; | ||
| 307 : | sh002i | 818 | my $setName = $self->{set}->set_id; |
| 308 : | my $problemNumber = $self->{problem}->problem_id; | ||
| 309 : | sh002i | 476 | |
| 310 : | sh002i | 809 | my $ce = $self->{ce}; |
| 311 : | sh002i | 818 | my $db = $self->{db}; |
| 312 : | sh002i | 476 | my $root = $ce->{webworkURLs}->{root}; |
| 313 : | my $courseName = $ce->{courseName}; | ||
| 314 : | gage | 1190 | my $timer0 = WeBWorK::Timing->new("time siblings"); |
| 315 : | $timer0->start; | ||
| 316 : | sh002i | 526 | print CGI::strong("Problems"), CGI::br(); |
| 317 : | |||
| 318 : | malsyned | 704 | my $effectiveUser = $self->{r}->param("effectiveUser"); |
| 319 : | sh002i | 476 | my @problems; |
| 320 : | gage | 1190 | # push @problems, $db->getMergedProblem($effectiveUser, $setName, $_) |
| 321 : | # foreach ($db->listUserProblems($effectiveUser, $setName)); | ||
| 322 : | @problems = $db->listUserProblems($effectiveUser, $setName); # this is much faster | ||
| 323 : | # foreach my $problem (sort { $a->problem_id <=> $b->problem_id } @problems) { | ||
| 324 : | foreach my $problem (sort { $a <=> $b } @problems) { | ||
| 325 : | print CGI::a({-href=>"$root/$courseName/$setName/".$problem."/?" | ||
| 326 : | sh002i | 692 | . $self->url_authen_args . "&displayMode=" . $self->{displayMode}}, |
| 327 : | gage | 1190 | "Problem ".$problem), CGI::br(); |
| 328 : | sh002i | 476 | } |
| 329 : | gage | 1190 | $timer0->stop; |
| 330 : | $timer0->save; | ||
| 331 : | ''; | ||
| 332 : | sh002i | 476 | } |
| 333 : | |||
| 334 : | sub nav { | ||
| 335 : | my $self = shift; | ||
| 336 : | my $args = $_[-1]; | ||
| 337 : | sh002i | 818 | my $setName = $self->{set}->set_id; |
| 338 : | my $problemNumber = $self->{problem}->problem_id; | ||
| 339 : | sh002i | 476 | |
| 340 : | sh002i | 809 | my $ce = $self->{ce}; |
| 341 : | sh002i | 818 | my $db = $self->{db}; |
| 342 : | sh002i | 476 | my $root = $ce->{webworkURLs}->{root}; |
| 343 : | my $courseName = $ce->{courseName}; | ||
| 344 : | |||
| 345 : | malsyned | 704 | my $wwdb = $self->{wwdb}; |
| 346 : | my $effectiveUser = $self->{r}->param("effectiveUser"); | ||
| 347 : | sh002i | 692 | my $tail = "&displayMode=".$self->{displayMode}; |
| 348 : | sh002i | 476 | |
| 349 : | malsyned | 795 | my @links = ("Problem List" , "$root/$courseName/$setName", "navProbList"); |
| 350 : | sh002i | 476 | |
| 351 : | sh002i | 1197 | # FIXME: this could be faster |
| 352 : | sh002i | 1096 | my $prevProblem = $db->getMergedProblem($effectiveUser, $setName, $problemNumber-1); |
| 353 : | my $nextProblem = $db->getMergedProblem($effectiveUser, $setName, $problemNumber+1); | ||
| 354 : | malsyned | 755 | unshift @links, "Previous Problem" , ($prevProblem |
| 355 : | sh002i | 818 | ? "$root/$courseName/$setName/".$prevProblem->problem_id |
| 356 : | malsyned | 795 | : "") , "navPrev"; |
| 357 : | malsyned | 755 | push @links, "Next Problem" , ($nextProblem |
| 358 : | sh002i | 818 | ? "$root/$courseName/$setName/".$nextProblem->problem_id |
| 359 : | malsyned | 795 | : "") , "navNext"; |
| 360 : | sh002i | 476 | |
| 361 : | sh002i | 692 | return $self->navMacro($args, $tail, @links); |
| 362 : | sh002i | 476 | } |
| 363 : | |||
| 364 : | sh002i | 449 | sub title { |
| 365 : | my $self = shift; | ||
| 366 : | sh002i | 818 | my $setName = $self->{set}->set_id; |
| 367 : | sh002i | 1197 | my $problemNumber = $self->{problem}->problem_id; |
| 368 : | sh002i | 476 | |
| 369 : | return "$setName : Problem $problemNumber"; | ||
| 370 : | sh002i | 449 | } |
| 371 : | |||
| 372 : | sub body { | ||
| 373 : | my $self = shift; | ||
| 374 : | |||
| 375 : | sh002i | 739 | return CGI::p(CGI::font({-color=>"red"}, "This problem is not available because the problem set that contains it is not yet open.")) |
| 376 : | unless $self->{isOpen}; | ||
| 377 : | sh002i | 738 | |
| 378 : | sh002i | 449 | # unpack some useful variables |
| 379 : | sh002i | 476 | my $r = $self->{r}; |
| 380 : | sh002i | 818 | my $db = $self->{db}; |
| 381 : | sh002i | 476 | my $set = $self->{set}; |
| 382 : | my $problem = $self->{problem}; | ||
| 383 : | sh002i | 1197 | my $editMode = $self->{editMode}; |
| 384 : | sh002i | 476 | my $permissionLevel = $self->{permissionLevel}; |
| 385 : | my $submitAnswers = $self->{submitAnswers}; | ||
| 386 : | sh002i | 719 | my $checkAnswers = $self->{checkAnswers}; |
| 387 : | sh002i | 623 | my $previewAnswers = $self->{previewAnswers}; |
| 388 : | sh002i | 719 | my %want = %{ $self->{want} }; |
| 389 : | sh002i | 1197 | my %can = %{ $self->{can} }; |
| 390 : | sh002i | 719 | my %must = %{ $self->{must} }; |
| 391 : | sh002i | 476 | my %will = %{ $self->{will} }; |
| 392 : | my $pg = $self->{pg}; | ||
| 393 : | sh002i | 449 | |
| 394 : | ##### translation errors? ##### | ||
| 395 : | |||
| 396 : | sh002i | 425 | if ($pg->{flags}->{error_flag}) { |
| 397 : | sh002i | 737 | return $self->errorOutput($pg->{errors}, $pg->{body_text}); |
| 398 : | sh002i | 425 | } |
| 399 : | sh002i | 415 | |
| 400 : | sh002i | 429 | ##### answer processing ##### |
| 401 : | |||
| 402 : | # if answers were submitted: | ||
| 403 : | if ($submitAnswers) { | ||
| 404 : | sh002i | 818 | # get a "pure" (unmerged) UserProblem to modify |
| 405 : | gage | 1007 | # this will be undefined if the problem has not been assigned to this user |
| 406 : | sh002i | 818 | my $pureProblem = $db->getUserProblem($problem->user_id, $problem->set_id, $problem->problem_id); |
| 407 : | sh002i | 431 | # store answers in DB for sticky answers |
| 408 : | sh002i | 429 | my %answersToStore; |
| 409 : | my %answerHash = %{ $pg->{answers} }; | ||
| 410 : | $answersToStore{$_} = $answerHash{$_}->{original_student_ans} | ||
| 411 : | foreach (keys %answerHash); | ||
| 412 : | my $answerString = encodeAnswers(%answersToStore, | ||
| 413 : | @{ $pg->{flags}->{ANSWER_ENTRY_ORDER} }); | ||
| 414 : | gage | 1007 | |
| 415 : | sh002i | 429 | $problem->last_answer($answerString); |
| 416 : | gage | 1007 | # if $pureProblem is defined ( there is a user ) then record the last answer. |
| 417 : | # FIXME (we're assuming that not being able to get a pure problem is enough to determine | ||
| 418 : | # whether or not the problem database needs to be updated. This should be thought through | ||
| 419 : | # more carefully to be sure. | ||
| 420 : | if ( defined($pureProblem) ) { | ||
| 421 : | $pureProblem->last_answer($answerString); | ||
| 422 : | $db->putUserProblem($pureProblem); | ||
| 423 : | #die "pureProblem = ", defined($pureProblem); | ||
| 424 : | sh002i | 429 | |
| 425 : | gage | 1007 | |
| 426 : | # store state in DB if it makes sense | ||
| 427 : | if ($will{recordAnswers}) { | ||
| 428 : | $problem->status($pg->{state}->{recorded_score}); | ||
| 429 : | $problem->attempted(1); | ||
| 430 : | $problem->num_correct($pg->{state}->{num_of_correct_ans}); | ||
| 431 : | $problem->num_incorrect($pg->{state}->{num_of_incorrect_ans}); | ||
| 432 : | $pureProblem->status($pg->{state}->{recorded_score}); | ||
| 433 : | $pureProblem->attempted(1); | ||
| 434 : | $pureProblem->num_correct($pg->{state}->{num_of_correct_ans}); | ||
| 435 : | $pureProblem->num_incorrect($pg->{state}->{num_of_incorrect_ans}); | ||
| 436 : | $db->putUserProblem($pureProblem); | ||
| 437 : | # write to the transaction log, just to make sure | ||
| 438 : | writeLog($self->{ce}, "transaction", | ||
| 439 : | $problem->problem_id."\t". | ||
| 440 : | $problem->set_id."\t". | ||
| 441 : | $problem->user_id."\t". | ||
| 442 : | $problem->source_file."\t". | ||
| 443 : | $problem->value."\t". | ||
| 444 : | $problem->max_attempts."\t". | ||
| 445 : | $problem->problem_seed."\t". | ||
| 446 : | $pureProblem->status."\t". | ||
| 447 : | $pureProblem->attempted."\t". | ||
| 448 : | $pureProblem->last_answer."\t". | ||
| 449 : | $pureProblem->num_correct."\t". | ||
| 450 : | $pureProblem->num_incorrect | ||
| 451 : | ); | ||
| 452 : | } | ||
| 453 : | sh002i | 431 | } |
| 454 : | sh002i | 425 | } |
| 455 : | gage | 794 | # logging student answers |
| 456 : | my $pastAnswerLog = undef; | ||
| 457 : | sh002i | 809 | if (defined( $self->{ce}->{webworkFiles}->{logs}->{'pastAnswerList'} )) { |
| 458 : | sh002i | 425 | |
| 459 : | sh002i | 809 | $pastAnswerLog = $self->{ce}->{webworkFiles}->{logs}->{'pastAnswerList'}; |
| 460 : | gage | 794 | |
| 461 : | if ($submitAnswers and defined($pastAnswerLog) ) { | ||
| 462 : | my $answerString = ""; | ||
| 463 : | my %answerHash = %{ $pg->{answers} }; | ||
| 464 : | $answerString = $answerString . $answerHash{$_}->{original_student_ans}."\t" | ||
| 465 : | foreach (sort keys %answerHash); | ||
| 466 : | gage | 1007 | $answerString = '' unless defined($answerString); # insure string is defined. |
| 467 : | sh002i | 809 | writeLog($self->{ce}, "pastAnswerList", |
| 468 : | sh002i | 818 | '|'.$problem->user_id. |
| 469 : | gage | 794 | '|'.$problem->set_id. |
| 470 : | sh002i | 818 | '|'.$problem->problem_id.'|'."\t". |
| 471 : | gage | 794 | time()."\t". |
| 472 : | $answerString, | ||
| 473 : | |||
| 474 : | ); | ||
| 475 : | |||
| 476 : | } | ||
| 477 : | |||
| 478 : | } | ||
| 479 : | # end logging student answers | ||
| 480 : | |||
| 481 : | sh002i | 429 | ##### output ##### |
| 482 : | sh002i | 1131 | |
| 483 : | malsyned | 755 | print CGI::start_div({class=>"problemHeader"}); |
| 484 : | sh002i | 1131 | |
| 485 : | sh002i | 1197 | # custom message for editor |
| 486 : | if ($permissionLevel >= 10 and defined $editMode) { | ||
| 487 : | if ($editMode eq "temporaryFile") { | ||
| 488 : | print CGI::p(CGI::i("Editing temporary file: ", $problem->source_file)); | ||
| 489 : | } elsif ($editMode eq "savedFile") { | ||
| 490 : | print CGI::p(CGI::i("Problem saved to: ", $problem->source_file)); | ||
| 491 : | } | ||
| 492 : | } | ||
| 493 : | |||
| 494 : | sh002i | 431 | # attempt summary |
| 495 : | if ($submitAnswers or $will{showCorrectAnswers}) { | ||
| 496 : | # print this if user submitted answers OR requested correct answers | ||
| 497 : | sh002i | 719 | print $self->attemptResults($pg, $submitAnswers, |
| 498 : | $will{showCorrectAnswers}, | ||
| 499 : | gage | 939 | $pg->{flags}->{showPartialCorrectAnswers}, 1, 1); |
| 500 : | sh002i | 719 | } elsif ($checkAnswers) { |
| 501 : | # print this if user previewed answers | ||
| 502 : | gage | 939 | print $self->attemptResults($pg, 1, 0, 1, 1, 1); |
| 503 : | sh002i | 719 | # show attempt answers |
| 504 : | # don't show correct answers | ||
| 505 : | # show attempt results (correctness) | ||
| 506 : | # don't show attempt previews | ||
| 507 : | sh002i | 623 | } elsif ($previewAnswers) { |
| 508 : | # print this if user previewed answers | ||
| 509 : | malsyned | 755 | print $self->attemptResults($pg, 1, 0, 0, 0, 1); |
| 510 : | sh002i | 719 | # show attempt answers |
| 511 : | sh002i | 623 | # don't show correct answers |
| 512 : | sh002i | 719 | # don't show attempt results (correctness) |
| 513 : | # show attempt previews | ||
| 514 : | sh002i | 431 | } |
| 515 : | gage | 392 | |
| 516 : | malsyned | 755 | print CGI::end_div(); |
| 517 : | |||
| 518 : | print CGI::start_div({class=>"problem"}); | ||
| 519 : | sh002i | 1131 | |
| 520 : | malsyned | 755 | # main form |
| 521 : | |||
| 522 : | CGI::startform("POST", $r->uri), | ||
| 523 : | $self->hidden_authen_fields, | ||
| 524 : | CGI::p($pg->{body_text}), | ||
| 525 : | CGI::p($pg->{result}->{msg} ? CGI::b("Note: ") : "", CGI::i($pg->{result}->{msg})), | ||
| 526 : | CGI::p( | ||
| 527 : | ($can{recordAnswers} | ||
| 528 : | ? CGI::submit(-name=>"submitAnswers", | ||
| 529 : | -label=>"Submit Answers") | ||
| 530 : | : ""), | ||
| 531 : | ($can{checkAnswers} | ||
| 532 : | ? CGI::submit(-name=>"checkAnswers", | ||
| 533 : | -label=>"Check Answers") | ||
| 534 : | : ""), | ||
| 535 : | CGI::submit(-name=>"previewAnswers", | ||
| 536 : | -label=>"Preview Answers"), | ||
| 537 : | ); | ||
| 538 : | gage | 794 | print CGI::end_div(); |
| 539 : | |||
| 540 : | print CGI::start_div({class=>"scoreSummary"}); | ||
| 541 : | sh002i | 1131 | |
| 542 : | sh002i | 431 | # score summary |
| 543 : | my $attempts = $problem->num_correct + $problem->num_incorrect; | ||
| 544 : | my $attemptsNoun = $attempts != 1 ? "times" : "time"; | ||
| 545 : | malsyned | 1034 | my $lastScore = sprintf("%.0f%%", $problem->status * 100); # Round to whole number |
| 546 : | sh002i | 431 | my ($attemptsLeft, $attemptsLeftNoun); |
| 547 : | if ($problem->max_attempts == -1) { | ||
| 548 : | # unlimited attempts | ||
| 549 : | $attemptsLeft = "unlimited"; | ||
| 550 : | $attemptsLeftNoun = "attempts"; | ||
| 551 : | } else { | ||
| 552 : | $attemptsLeft = $problem->max_attempts - $attempts; | ||
| 553 : | $attemptsLeftNoun = $attemptsLeft == 1 ? "attempt" : "attempts"; | ||
| 554 : | } | ||
| 555 : | malsyned | 755 | |
| 556 : | my $setClosed = 0; | ||
| 557 : | sh002i | 476 | my $setClosedMessage; |
| 558 : | if (time < $set->open_date or time > $set->due_date) { | ||
| 559 : | malsyned | 755 | $setClosed = 1; |
| 560 : | sh002i | 476 | $setClosedMessage = "This problem set is closed."; |
| 561 : | if ($permissionLevel > 0) { | ||
| 562 : | sh002i | 1131 | $setClosedMessage .= " However, since you are a privileged user, additional attempts will be recorded."; |
| 563 : | sh002i | 476 | } else { |
| 564 : | $setClosedMessage .= " Additional attempts will not be recorded."; | ||
| 565 : | } | ||
| 566 : | } | ||
| 567 : | sh002i | 449 | print CGI::p( |
| 568 : | "You have attempted this problem $attempts $attemptsNoun.", CGI::br(), | ||
| 569 : | sh002i | 431 | $problem->attempted |
| 570 : | sh002i | 449 | ? "Your recorded score is $lastScore." . CGI::br() |
| 571 : | sh002i | 431 | : "", |
| 572 : | malsyned | 755 | $setClosed ? $setClosedMessage : "You have $attemptsLeft $attemptsLeftNoun remaining." |
| 573 : | sh002i | 431 | ); |
| 574 : | gage | 794 | print CGI::end_div(); |
| 575 : | malsyned | 755 | |
| 576 : | sh002i | 1131 | # save state for viewOptions |
| 577 : | print CGI::hidden( | ||
| 578 : | -name => "showOldAnswers", | ||
| 579 : | -value => $will{showOldAnswers} | ||
| 580 : | ), | ||
| 581 : | CGI::hidden( | ||
| 582 : | -name => "showCorrectAnswers", | ||
| 583 : | -value => $will{showCorrectAnswers} | ||
| 584 : | ), | ||
| 585 : | CGI::hidden( | ||
| 586 : | -name => "showHints", | ||
| 587 : | -value => $will{showHints}), | ||
| 588 : | CGI::hidden( | ||
| 589 : | -name => "showSolutions", | ||
| 590 : | -value => $will{showSolutions}, | ||
| 591 : | ), | ||
| 592 : | CGI::hidden( | ||
| 593 : | -name => "displayMode", | ||
| 594 : | -value => $self->{displayMode} | ||
| 595 : | ); | ||
| 596 : | |||
| 597 : | # end of main form | ||
| 598 : | print CGI::endform(); | ||
| 599 : | |||
| 600 : | # stuff we need below (pull these out at the beginning?) | ||
| 601 : | sh002i | 809 | my $ce = $self->{ce}; |
| 602 : | sh002i | 667 | my $root = $ce->{webworkURLs}->{root}; |
| 603 : | my $courseName = $ce->{courseName}; | ||
| 604 : | gage | 794 | |
| 605 : | sh002i | 1131 | print CGI::start_div({class=>"problemFooter"}); |
| 606 : | |||
| 607 : | gage | 794 | # arguments for answer inspection button |
| 608 : | my $prof_url = $ce->{webworkURLs}->{oldProf}; | ||
| 609 : | my $cgi_url = $prof_url; | ||
| 610 : | $cgi_url=~ s|/[^/]*$||; # clip profLogin.pl | ||
| 611 : | my $authen_args = $self->url_authen_args(); | ||
| 612 : | my $showPastAnswersURL = "$cgi_url/showPastAnswers.pl"; | ||
| 613 : | |||
| 614 : | # print answer inspection button | ||
| 615 : | sh002i | 1131 | if ($self->{permissionLevel} > 0) { |
| 616 : | gage | 794 | print "\n", |
| 617 : | CGI::start_form(-method=>"POST",-action=>$showPastAnswersURL,-target=>"information"),"\n", | ||
| 618 : | sh002i | 1131 | $self->hidden_authen_fields,"\n", |
| 619 : | CGI::hidden(-name => 'course', -value=>$courseName), "\n", | ||
| 620 : | CGI::hidden(-name => 'probNum', -value=>$problem->problem_id), "\n", | ||
| 621 : | CGI::hidden(-name => 'setNum', -value=>$problem->set_id), "\n", | ||
| 622 : | CGI::hidden(-name => 'User', -value=>$problem->user_id), "\n", | ||
| 623 : | CGI::p( {-align=>"left"}, | ||
| 624 : | CGI::submit(-name => 'action', -value=>'Show Past Answers') | ||
| 625 : | ), "\n", | ||
| 626 : | CGI::endform(); | ||
| 627 : | } | ||
| 628 : | sh002i | 667 | |
| 629 : | sh002i | 1131 | #print CGI::end_div(); |
| 630 : | # | ||
| 631 : | #print CGI::start_div(); | ||
| 632 : | gage | 794 | |
| 633 : | sh002i | 1131 | # arguments for feedback form |
| 634 : | my $feedbackURL = "$root/$courseName/feedback/"; | ||
| 635 : | gage | 794 | |
| 636 : | sh002i | 1131 | #print feedback form |
| 637 : | gage | 940 | |
| 638 : | CGI::start_form(-method=>"POST", -action=>$feedbackURL),"\n", | ||
| 639 : | $self->hidden_authen_fields,"\n", | ||
| 640 : | CGI::hidden("module", __PACKAGE__),"\n", | ||
| 641 : | CGI::hidden("set", $set->set_id),"\n", | ||
| 642 : | CGI::hidden("problem", $problem->problem_id),"\n", | ||
| 643 : | CGI::hidden("displayMode", $self->{displayMode}),"\n", | ||
| 644 : | CGI::hidden("showOldAnswers", $will{showOldAnswers}),"\n", | ||
| 645 : | CGI::hidden("showCorrectAnswers", $will{showCorrectAnswers}),"\n", | ||
| 646 : | CGI::hidden("showHints", $will{showHints}),"\n", | ||
| 647 : | CGI::hidden("showSolutions", $will{showSolutions}),"\n", | ||
| 648 : | CGI::p({-align=>"left"}, | ||
| 649 : | CGI::submit(-name=>"feedbackForm", -label=>"Contact instructor") | ||
| 650 : | ), | ||
| 651 : | CGI::endform(),"\n"; | ||
| 652 : | |||
| 653 : | gage | 903 | # FIXME print editor link |
| 654 : | gage | 926 | # print editor link if the user is an instructor AND the file is not in temporary editing mode |
| 655 : | if ($self->{permissionLevel}>=10 and ( (not defined($self->{edit_mode})) or $self->{edit_mode} eq 'savedFile') ) { | ||
| 656 : | malsyned | 1041 | print CGI::a({-href=>$ce->{webworkURLs}->{root}."/$courseName/instructor/pgProblemEditor/".$set->set_id. |
| 657 : | gage | 906 | '/'.$problem->problem_id.'?'.$self->url_authen_args},'Edit this problem'); |
| 658 : | } | ||
| 659 : | |||
| 660 : | sh002i | 1131 | print CGI::end_div(); |
| 661 : | gage | 940 | |
| 662 : | sh002i | 558 | # warning output |
| 663 : | sh002i | 1131 | #if ($pg->{warnings} ne "") { |
| 664 : | # print CGI::hr(), $self->warningOutput($pg->{warnings}); | ||
| 665 : | #} | ||
| 666 : | sh002i | 558 | |
| 667 : | sh002i | 424 | # debugging stuff |
| 668 : | sh002i | 747 | if (0) { |
| 669 : | sh002i | 738 | |
| 670 : | CGI::hr(), | ||
| 671 : | CGI::h2("debugging information"), | ||
| 672 : | CGI::h3("form fields"), | ||
| 673 : | ref2string($self->{formFields}), | ||
| 674 : | CGI::h3("user object"), | ||
| 675 : | ref2string($self->{user}), | ||
| 676 : | CGI::h3("set object"), | ||
| 677 : | ref2string($set), | ||
| 678 : | CGI::h3("problem object"), | ||
| 679 : | ref2string($problem), | ||
| 680 : | CGI::h3("PG object"), | ||
| 681 : | ref2string($pg, {'WeBWorK::PG::Translator' => 1}); | ||
| 682 : | } | ||
| 683 : | gage | 392 | |
| 684 : | sh002i | 424 | return ""; |
| 685 : | malsyned | 353 | } |
| 686 : | |||
| 687 : | sh002i | 431 | ##### output utilities ##### |
| 688 : | sh002i | 429 | |
| 689 : | malsyned | 755 | sub attemptResults($$$$$$) { |
| 690 : | sh002i | 623 | my $self = shift; |
| 691 : | sh002i | 425 | my $pg = shift; |
| 692 : | sh002i | 431 | my $showAttemptAnswers = shift; |
| 693 : | sh002i | 425 | my $showCorrectAnswers = shift; |
| 694 : | sh002i | 431 | my $showAttemptResults = $showAttemptAnswers && shift; |
| 695 : | malsyned | 755 | my $showSummary = shift; |
| 696 : | sh002i | 683 | my $showAttemptPreview = shift || 0; |
| 697 : | sh002i | 425 | my $problemResult = $pg->{result}; # the overall result of the problem |
| 698 : | my @answerNames = @{ $pg->{flags}->{ANSWER_ENTRY_ORDER} }; | ||
| 699 : | |||
| 700 : | sh002i | 685 | my $showMessages = $showAttemptAnswers && grep { $pg->{answers}->{$_}->{ans_message} } @answerNames; |
| 701 : | |||
| 702 : | malsyned | 755 | my $header = CGI::th("Part"); |
| 703 : | $header .= $showAttemptAnswers ? CGI::th("Entered") : ""; | ||
| 704 : | $header .= $showAttemptPreview ? CGI::th("Answer Preview") : ""; | ||
| 705 : | $header .= $showCorrectAnswers ? CGI::th("Correct") : ""; | ||
| 706 : | $header .= $showAttemptResults ? CGI::th("Result") : ""; | ||
| 707 : | sh002i | 685 | $header .= $showMessages ? CGI::th("messages") : ""; |
| 708 : | sh002i | 425 | my @tableRows = ( $header ); |
| 709 : | my $numCorrect; | ||
| 710 : | foreach my $name (@answerNames) { | ||
| 711 : | my $answerResult = $pg->{answers}->{$name}; | ||
| 712 : | sh002i | 429 | my $studentAnswer = $answerResult->{student_ans}; # original_student_ans |
| 713 : | sh002i | 683 | my $preview = ($showAttemptPreview |
| 714 : | ? $self->previewAnswer($answerResult) | ||
| 715 : | : ""); | ||
| 716 : | sh002i | 425 | my $correctAnswer = $answerResult->{correct_ans}; |
| 717 : | my $answerScore = $answerResult->{score}; | ||
| 718 : | sh002i | 685 | my $answerMessage = $showMessages ? $answerResult->{ans_message} : ""; |
| 719 : | sh002i | 425 | |
| 720 : | $numCorrect += $answerScore > 0; | ||
| 721 : | sh002i | 555 | my $resultString = $answerScore ? "correct" : "incorrect"; |
| 722 : | sh002i | 425 | |
| 723 : | sh002i | 555 | # get rid of the goofy prefix on the answer names (supposedly, the format |
| 724 : | sh002i | 683 | # of the answer names is changeable. this only fixes it for "AnSwEr" |
| 725 : | sh002i | 555 | $name =~ s/^AnSwEr//; |
| 726 : | |||
| 727 : | sh002i | 449 | my $row = CGI::td($name); |
| 728 : | gage | 1128 | $row .= $showAttemptAnswers ? CGI::td(nbsp($studentAnswer)) : ""; |
| 729 : | $row .= $showAttemptPreview ? CGI::td(nbsp($preview)) : ""; | ||
| 730 : | $row .= $showCorrectAnswers ? CGI::td(nbsp($correctAnswer)) : ""; | ||
| 731 : | $row .= $showAttemptResults ? CGI::td(nbsp($resultString)) : ""; | ||
| 732 : | $row .= $answerMessage ? CGI::td(nbsp($answerMessage)) : ""; | ||
| 733 : | sh002i | 425 | push @tableRows, $row; |
| 734 : | } | ||
| 735 : | |||
| 736 : | malsyned | 755 | my $numIncorrectNoun = scalar @answerNames == 1 ? "question" : "questions"; |
| 737 : | malsyned | 1049 | my $scorePercent = sprintf("%.0f%%", $problemResult->{score} * 100); |
| 738 : | malsyned | 755 | my $summary = "On this attempt, you answered $numCorrect out of " |
| 739 : | . scalar @answerNames . " $numIncorrectNoun correct, for a score of $scorePercent."; | ||
| 740 : | return CGI::table({-class=>"attemptResults"}, CGI::Tr(\@tableRows)) . ($showSummary ? CGI::p($summary) : ""); | ||
| 741 : | sh002i | 425 | } |
| 742 : | gage | 1128 | sub nbsp { |
| 743 : | my $str = shift; | ||
| 744 : | ($str) ? $str : ' '; # returns non-breaking space for empty strings | ||
| 745 : | } | ||
| 746 : | sh002i | 449 | sub viewOptions($) { |
| 747 : | my $self = shift; | ||
| 748 : | my $displayMode = $self->{displayMode}; | ||
| 749 : | my %must = %{ $self->{must} }; | ||
| 750 : | my %can = %{ $self->{can} }; | ||
| 751 : | my %will = %{ $self->{will} }; | ||
| 752 : | sh002i | 431 | |
| 753 : | my $optionLine; | ||
| 754 : | $can{showOldAnswers} and $optionLine .= join "", | ||
| 755 : | gage | 940 | "Show: ".CGI::br(), |
| 756 : | sh002i | 449 | CGI::checkbox( |
| 757 : | sh002i | 429 | -name => "showOldAnswers", |
| 758 : | sh002i | 431 | -checked => $will{showOldAnswers}, |
| 759 : | -label => "Saved answers", | ||
| 760 : | gage | 940 | ), " ".CGI::br(); |
| 761 : | sh002i | 431 | $can{showCorrectAnswers} and $optionLine .= join "", |
| 762 : | sh002i | 449 | CGI::checkbox( |
| 763 : | sh002i | 429 | -name => "showCorrectAnswers", |
| 764 : | sh002i | 431 | -checked => $will{showCorrectAnswers}, |
| 765 : | sh002i | 429 | -label => "Correct answers", |
| 766 : | gage | 940 | ), " ".CGI::br(); |
| 767 : | sh002i | 431 | $can{showHints} and $optionLine .= join "", |
| 768 : | sh002i | 449 | CGI::checkbox( |
| 769 : | sh002i | 429 | -name => "showHints", |
| 770 : | sh002i | 431 | -checked => $will{showHints}, |
| 771 : | sh002i | 429 | -label => "Hints", |
| 772 : | gage | 940 | ), " ".CGI::br(); |
| 773 : | sh002i | 431 | $can{showSolutions} and $optionLine .= join "", |
| 774 : | sh002i | 449 | CGI::checkbox( |
| 775 : | sh002i | 429 | -name => "showSolutions", |
| 776 : | sh002i | 431 | -checked => $will{showSolutions}, |
| 777 : | sh002i | 429 | -label => "Solutions", |
| 778 : | gage | 940 | ), " ".CGI::br(); |
| 779 : | sh002i | 449 | $optionLine and $optionLine .= join "", CGI::br(); |
| 780 : | sh002i | 431 | |
| 781 : | gage | 940 | return CGI::div({-style=>"border: thin groove; padding: 1ex; margin: 2ex align: left"}, |
| 782 : | "View equations as: ".CGI::br(), | ||
| 783 : | sh002i | 449 | CGI::radio_group( |
| 784 : | sh002i | 431 | -name => "displayMode", |
| 785 : | -values => ['plainText', 'formattedText', 'images'], | ||
| 786 : | -default => $displayMode, | ||
| 787 : | gage | 940 | -linebreak=>'true', |
| 788 : | sh002i | 431 | -labels => { |
| 789 : | gage | 940 | plainText => "plain", |
| 790 : | formattedText => "formatted", | ||
| 791 : | sh002i | 431 | images => "images", |
| 792 : | } | ||
| 793 : | gage | 940 | ), CGI::br(),CGI::hr(), |
| 794 : | sh002i | 431 | $optionLine, |
| 795 : | gage | 942 | CGI::submit(-name=>"redisplay", -label=>"Save Options"), |
| 796 : | sh002i | 429 | ); |
| 797 : | } | ||
| 798 : | |||
| 799 : | sh002i | 623 | sub previewAnswer($$) { |
| 800 : | my ($self, $answerResult) = @_; | ||
| 801 : | sh002i | 809 | my $ce = $self->{ce}; |
| 802 : | malsyned | 718 | my $effectiveUser = $self->{effectiveUser}; |
| 803 : | my $set = $self->{set}; | ||
| 804 : | my $problem = $self->{problem}; | ||
| 805 : | my $displayMode = $self->{displayMode}; | ||
| 806 : | sh002i | 623 | |
| 807 : | sh002i | 682 | # note: right now, we have to do things completely differently when we are |
| 808 : | # rendering math from INSIDE the translator and from OUTSIDE the translator. | ||
| 809 : | # so we'll just deal with each case explicitly here. there's some code | ||
| 810 : | # duplication that can be dealt with later by abstracting out tth/dvipng/etc. | ||
| 811 : | sh002i | 623 | |
| 812 : | my $tex = $answerResult->{preview_latex_string}; | ||
| 813 : | |||
| 814 : | sh002i | 818 | return "" if $tex eq ""; |
| 815 : | sh002i | 737 | |
| 816 : | sh002i | 682 | if ($displayMode eq "plainText") { |
| 817 : | return $tex; | ||
| 818 : | } elsif ($displayMode eq "formattedText") { | ||
| 819 : | my $tthCommand = $ce->{externalPrograms}->{tth} | ||
| 820 : | . " -L -f5 -r 2> /dev/null <<END_OF_INPUT; echo > /dev/null\n" | ||
| 821 : | sh002i | 737 | . "\\(".$tex."\\)\n" |
| 822 : | sh002i | 682 | . "END_OF_INPUT\n"; |
| 823 : | |||
| 824 : | # call tth | ||
| 825 : | my $result = `$tthCommand`; | ||
| 826 : | if ($?) { | ||
| 827 : | return "<b>[tth failed: $? $@]</b>"; | ||
| 828 : | } | ||
| 829 : | return $result; | ||
| 830 : | } elsif ($displayMode eq "images") { | ||
| 831 : | # how are we going to name this? | ||
| 832 : | sh002i | 1016 | my $targetPathCommon = "/m2i/" |
| 833 : | sh002i | 919 | . $effectiveUser->user_id . "." |
| 834 : | sh002i | 818 | . $set->set_id . "." |
| 835 : | . $problem->problem_id . "." | ||
| 836 : | sh002i | 682 | . $answerResult->{ans_name} . ".png"; |
| 837 : | |||
| 838 : | # figure out where to put things | ||
| 839 : | sh002i | 1147 | my $wd = makeTempDirectory($ce->{courseDirs}->{html_temp}, "webwork-dvipng"); |
| 840 : | sh002i | 682 | my $latex = $ce->{externalPrograms}->{latex}; |
| 841 : | my $dvipng = $ce->{externalPrograms}->{dvipng}; | ||
| 842 : | my $targetPath = $ce->{courseDirs}->{html_temp} . $targetPathCommon; | ||
| 843 : | # should use surePathToTmpFile, but we have to | ||
| 844 : | # isolate it from the problem enivronment first | ||
| 845 : | my $targetURL = $ce->{courseURLs}->{html_temp} . $targetPathCommon; | ||
| 846 : | |||
| 847 : | # call dvipng to generate a preview | ||
| 848 : | dvipng($wd, $latex, $dvipng, $tex, $targetPath); | ||
| 849 : | sh002i | 920 | rmtree($wd, 0, 0); |
| 850 : | sh002i | 682 | if (-e $targetPath) { |
| 851 : | return "<img src=\"$targetURL\" alt=\"$tex\" />"; | ||
| 852 : | } else { | ||
| 853 : | return "<b>[math2img failed]</b>"; | ||
| 854 : | } | ||
| 855 : | sh002i | 623 | } |
| 856 : | } | ||
| 857 : | gage | 939 | |
| 858 : | gage | 794 | ##### logging subroutine #### |
| 859 : | sh002i | 623 | |
| 860 : | gage | 794 | |
| 861 : | |||
| 862 : | sh002i | 431 | ##### permission queries ##### |
| 863 : | sh002i | 429 | |
| 864 : | # this stuff should be abstracted out into the permissions system | ||
| 865 : | # however, the permission system only knows about things in the | ||
| 866 : | # course environment and the username. hmmm... | ||
| 867 : | |||
| 868 : | sh002i | 431 | # also, i should fix these so that they have a consistent calling |
| 869 : | # format -- perhaps: | ||
| 870 : | # canPERM($courseEnv, $user, $set, $problem, $permissionLevel) | ||
| 871 : | |||
| 872 : | sh002i | 429 | sub canShowCorrectAnswers($$) { |
| 873 : | my ($permissionLevel, $answerDate) = @_; | ||
| 874 : | return $permissionLevel > 0 || time > $answerDate; | ||
| 875 : | } | ||
| 876 : | |||
| 877 : | sub canShowSolutions($$) { | ||
| 878 : | my ($permissionLevel, $answerDate) = @_; | ||
| 879 : | return canShowCorrectAnswers($permissionLevel, $answerDate); | ||
| 880 : | } | ||
| 881 : | |||
| 882 : | sh002i | 431 | sub canRecordAnswers($$$$$) { |
| 883 : | my ($permissionLevel, $openDate, $dueDate, $maxAttempts, $attempts) = @_; | ||
| 884 : | my $permHigh = $permissionLevel > 0; | ||
| 885 : | my $timeOK = time >= $openDate && time <= $dueDate; | ||
| 886 : | sh002i | 617 | my $attemptsOK = $maxAttempts == -1 || $attempts <= $maxAttempts; |
| 887 : | my $recordAnswers = $permHigh || ($timeOK && $attemptsOK); | ||
| 888 : | return $recordAnswers; | ||
| 889 : | sh002i | 429 | } |
| 890 : | |||
| 891 : | sh002i | 756 | sub canCheckAnswers($$) { |
| 892 : | my ($permissionLevel, $answerDate) = @_; | ||
| 893 : | my $permHigh = $permissionLevel > 0; | ||
| 894 : | my $timeOK = time >= $answerDate; | ||
| 895 : | my $recordAnswers = $permHigh || $timeOK; | ||
| 896 : | return $recordAnswers; | ||
| 897 : | sh002i | 747 | } |
| 898 : | |||
| 899 : | sh002i | 429 | sub mustRecordAnswers($) { |
| 900 : | my ($permissionLevel) = @_; | ||
| 901 : | return $permissionLevel == 0; | ||
| 902 : | } | ||
| 903 : | |||
| 904 : | sh002i | 415 | 1; |
| aubreyja at gmail dot com | ViewVC Help |
| Powered by ViewVC 1.0.9 |