# -*- Tcl -*-
########################################################################
# Inclass-Exam workflow, designed similar to online-exam
# ======================================================
#
# Defining exams: This workflow lets a lecturer choose from a
# predefined set of exam questions, which are typically open text,
# short text, single or multiple choice questions.  The lecturer
# selects test questions via drag and drop. The lecturer can perform a
# test run of the created exam, and can get the results via a result
# table.
#
# Publishing and closing exams: When a lecturer is satisfied with the
# exam, the exam can be published. In this step, all answers of the
# testing phase are deleted. In the process of publishing, the link to
# start the exam is offered to the user.  When the exam is published,
# the lecturer can see the incoming answers in the report by refreshing
# the page. When the exam is done, it is unpublished. The workflow
# offers the lecturer to see a summary of the results in form of a
# table (an to download the results via csv), or the lecturer can
# produce a printer friendly version of the answers.
#
# An admin might wish to add the following entries to the folder to ease
# creation of exercises and exams
#
#   {clear_menu -menu New}
#
#   {entry -name New.Item.TextInteraction -form en:edit-interaction.wf -query p.item_type=Text}
#   {entry -name New.Item.ShortTextInteraction -form en:edit-interaction.wf -query p.item_type=ShortText}
#   {entry -name New.Item.SCInteraction -form en:edit-interaction.wf -query p.item_type=SC}
#   {entry -name New.Item.MCInteraction -form en:edit-interaction.wf -query p.item_type=MC}
#   {entry -name New.Item.ReorderInteraction -form en:edit-interaction.wf -query p.item_type=Reorder}
#   {entry -name New.Item.UploadInteraction -form en:edit-interaction.wf -query p.item_type=Upload}
#
#   {entry -name New.App.Exam -label "Inclass Exam" -form en:inclass-exam.wf}
#
# Alternatively, one can use the programmatic setup for the menubar
# via config=test-items in case a site wants to change all setups in
# all instances for menubars by updating a single file.
#
#   {config -use test-items}
#
# The policy has to allow the following methods on FormPages:
#
#  - "answer" (for students),
#  - "proctor" (for students),
#  - "view-my-exam" (for students),
#  - "edit" (for students),
#  - "poll" (for lecturers),
#  - "print-answers" (for lecturers),
#  - "print-answer-table" (for lecturers),
#  - "print-participants" (for lecturers),
#  - "exam-summary" (for lecturers),
#  - "delete" (for lecturers),
#  - "qrcode" (for lecturers)
#
# Gustaf Neumann, Feb 2012-2021
########################################################################
set :autoname 1   ;# to avoid editable name field
set :policy ::xowf::test_item::test-item-policy-publish
set :debug 0
set :live_updates 1
set :QM ::xowf::test_item::question_manager

Property realexam -default 1 -allow_query_parameter true

Action select -next_state created -label #xowf.online-exam-select# \
    -title #xowf.online-exam-title-select#
Action publish -next_state published -state_safe true -label #xowf.online-exam-publish# \
    -title #xowf.online-exam-title-publish#
Action unpublish -next_state done -state_safe true -label #xowf.online-exam-unpublish#
Action republish -next_state published -label #xowf.online-exam-republish# \
    -title #xowf.online-exam-title-republish#
Action restart -next_state initial -label #xowf.restart# \
    -title #xowf.online-exam-title-restart#
Action open_submission_review -next_state submission_review -label #xowf.open_submission_review# \
    -title #xowf.open_submission_review_title#
Action close_submission_review -next_state done -label #xowf.close_submission_review# \
    -title #xowf.close_submission_review_title#

State parameter {
  {extra_css {/resources/xowf/test-item.css}}
}
State initial -actions {select} -form en:select_question.form -view_method edit
State created -actions {publish restart} -form_loader load_form -view_method edit \
    -form "#xowf.inclass-exam-draft_exam#"
State published -actions {unpublish} -form_loader load_form -view_method edit \
    -form "#xowf.inclass-exam-open#"
State done -actions {republish open_submission_review} \
    -in_role swa {
      -actions {republish open_submission_review restart}
    } \
    -form_loader load_form -view_method edit \
    -form "#xowf.inclass-exam-closed#"
State submission_review -actions {close_submission_review} -form_loader load_form -view_method edit \
    -form "#xowf.inclass-exam-review#"

########################################################################
# Activate action select: After the lecturer has selected the
# exercises, the answer workflow is created.
#
select proc activate {obj} {
  xowf::test_item::answer_manager create_workflow \
      -answer_workflow /packages/xowf/lib/inclass-exam-answer.wf \
      $obj
}

########################################################################
# Activate action publish: delete all responses for the workflow and
# publish user participation link.
#
publish proc activate {obj} {
  #
  # On the first activation of "publish", older data (e.g. from
  # testruns) is removed. When the exam was already published before -
  # e.g. a manual publish operation before an automatic one - NO
  # cleanup is performed to avoid potential loss of submission data.
  #
  set revision_sets     [$obj get_revision_sets]
  set published_periods [xowf::test_item::answer_manager state_periods $revision_sets -state published]
  if {[llength $published_periods] == 0} {
    xowf::test_item::answer_manager delete_all_answer_data $obj
  }
  :publish_link $obj
}

########################################################################
# Activate action republish: publish user participation link.
#
republish proc activate {obj} {
  :publish_link $obj
}

########################################################################
# When the user un-publishes an exam, just the user participation
# link should be removed for the users
#
unpublish proc activate {obj} {
  :unpublish_link $obj
}

########################################################################
# When the user restarts an exam, make sure that already scheduled
# atjobs are removed.
#
restart proc activate {obj} {
  xowf::test_item::answer_manager delete_scheduled_atjobs $obj
}

########################################################################
# When the user opens the submission review, offer a link.
#
open_submission_review proc activate {obj} {
  set aLink [$obj pretty_link -query m=view-my-exam]
  $obj util_user_message -html -message \
      "[$obj name] exam review is available as <a target='_blank' href='[ns_quotehtml $aLink]'>[ns_quotehtml $aLink]</a>"
}

########################################################################
# publish_link: make the user participation link available for the
# target group
#
Action instproc publish_link {obj} {
  set aLink [$obj pretty_link -query m=answer]
  $obj util_user_message -html \
      -message "[ns_quotehtml [$obj name]] is available as <a target='_blank' href='[ns_quotehtml $aLink]'>[ns_quotehtml $aLink]</a>"
  # TODO: make it happen in the LMS
}
########################################################################
# unpublish_link: remove the user participation link for the target
# group
#
Action instproc unpublish_link {obj} {
  $obj util_user_message -html -message "[$obj name] is closed</a>"
  # TODO: make it happen in the LMS
}

########################################################################
# form loader: create dynamically a form containing the disabled
# questions as a preview and the survey results (the results can be
# refreshed).
#
:proc load_form {ctx title} {
  set obj [$ctx object]
  set state [$obj property _state]
  set proctoring [$obj property proctoring 0]

  set combined_form_info [${:QM} combined_question_form -with_numbers $obj]
  set fullQuestionForm [${:QM} aggregated_form $combined_form_info]
  set full_fc [dict get $combined_form_info disabled_form_constraints]

  #:log  fullQuestionForm=$fullQuestionForm
  set text "<h3>[ns_quotehtml $title]</h3>"
  set menu ""

  set text [${:QM} exam_info_block \
                -combined_form_info $combined_form_info \
                $obj]
  set detail_link [$obj pretty_link -query m=exam-summary]
  append text "<p><a class='btn btn-default' href='$detail_link'>#xowf.detailed_summary#</a></p>"

  set wf [xowf::test_item::answer_manager get_answer_wf $obj]
  if {$wf eq ""} {
    :msg "cannot get current workflow for [$obj name]"
    set tLink "."
    set aLink "."
  } else {
    #
    # Always compute the test-run and answer link.
    #
    set wf_pretty_link [$wf pretty_link]
    set tLink [export_vars -base $wf_pretty_link {
      {m create-new} {p.return_url "[::xo::cc url]"} {p.try_out_mode 1} {title "[$obj title]"}
    }]
    set aLink [$obj pretty_link -query m=answer]

    if {$proctoring} {
      #
      # send link via "m=proctor"
      #
      set tLink [export_vars -base [$obj pretty_link] {
        {m proctor} {link "$tLink&p.proctor=1"}
      }]
      #
      # We could send answer link ("aLink") as well this way, but we
      # want to keep the link short, therefore, we handle the proctor
      # link inside the www-answer method.
      #
    }

    set answers [xowf::test_item::answer_manager get_answers $wf]

    #
    # Per default, the entries are disabled. When there are answers,
    # these will be enabled.
    #
    set link_disabled [expr {[llength $answers] == 0 ? "link-disabled" : ""}]
    set md [subst {
      listing      {obj $wf  m list label #xowf.online-exam-exam_instances# glyph list}
      participants {obj $obj m print-participants label #xowf.Participants# glyph user}
      protocol     {obj $obj m print-answers label #xowf.online-exam-protocol# glyph list-alt}
      results      {obj $obj m print-answer-table label #xowf.online-exam-results-table# glyph th-list}
    }]

    if {![acs_user::site_wide_admin_p -user_id [::xo::cc user_id]]} {
      dict unset md listing
    }
    dict unset md results

    set menu ""
    dict for {name d} $md {
      set href [[dict get $d obj] pretty_link -query m=[dict get $d m]]
      append menu "<a class='list-group-item $link_disabled' href='[ns_quotehtml $href]'>" \
          "<span class='glyphicon glyphicon-[dict get $d glyph]'></span> [ns_quotehtml [dict get $d label]]</a>\n"
    }
  }

  switch $state {
    "created" -
    "done" -
    "submission_review" -
    "published" {
      #
      # In inclass cases, never show all questions on screen, since
      # the lecturer might have the screen on the projector.
      #
      template::add_script -src urn:ad:js:bootstrap3
      set fullQuestionForm [subst {
        <button type="button" class="btn btn-default btn-sm dropdown-toggle" data-toggle="collapse" data-target="#questions">#xowf.questions# <span class="caret"></span></button>
        <div id="questions" class="collapse">
        $fullQuestionForm
        </div>
      }]
    }
  }

  set extraAction ""
  switch $state {
    "created"   {
      append extraAction "<br>" \
          "#xowf.online-exam-try_out# " \
          "<a class='btn btn-default' href='[ns_quotehtml $tLink]' target=”_blank”>#xowf.testrun#</a>"
    }
    "published" {
      append extraAction "<br>" \
          "#xowf.online-exam-can_answer# " \
          "<a class='answer' href='$aLink'>[ns_quotehtml $aLink]</a>"
    }
  }

  set www_method [xo::cc query_parameter m:token]
  if {$www_method ni {edit view}} {
    set marked ""
  } else {
    set answerStatus ""
    set marked ""

    if {$state in {published done submission_review} || [llength $answers] > 0 } {
      if {$state eq "done"} {
        set marked [xowf::test_item::answer_manager marked_results -obj $obj -wf $wf $combined_form_info]
        set marked ""  ;# not needed right now
      }
      set answerStatus [xowf::test_item::answer_manager answers_panel  \
                            -heading "#xowf.online-exam-submitted_exams_heading#" \
                            -submission_msg "#xowf.online-exam-submitted_exams_msg#" \
                            -polling=[expr {${:live_updates} && $state ni {initial created done}}] \
                            -manager_obj $obj \
                            -target_state done \
                            -extra_text $menu \
                            -wf $wf]
    }

    set qrCode ""
    set countdownHTML ""
    if {$state eq "published"} {
      set src [$obj pretty_link -query m=qrcode]
      set qrCode [subst {<div><img class="img-thumbnail qrcode" src="[ns_quotehtml $src]" ></div>}]
      set target_time [${:QM} exam_target_time \
                           -manager $obj -base_time [$obj last_modified]]
      set countdownHTML [xowf::test_item::answer_manager countdown_timer \
                             -target_time $target_time -id "countdown"]
    }

    # Remove wrapping forms
    regsub -all {</?form[^>]*>} $fullQuestionForm {} fullQuestionForm

    append text [subst {
      <div class='container-fluid'><div class='row'>
      <div class="col-sm-9">$answerStatus</div>
      <div class="col-sm-3">$qrCode</div>
      <div class="col-xs-12 quiz-preview">$fullQuestionForm</div>
      <div class="col-sm-6">$countdownHTML</div>
      </div></div>
    }]
  }

  set footer " $extraAction"
  set f [::xowiki::Form new \
             -destroy_on_cleanup \
             -set name en:question \
             -form [subst {<form>$text$marked$footer</form> text/html}] \
             -text {} \
             -anon_instances t \
             -form_constraints $full_fc \
            ]
}

########################################################################
#
# Object specific operations
#
########################################################################

:object-specific {
  set t0 [clock clicks -milliseconds]
  #ns_log notice "==== object-specific inclass-exam [self] state ${:state}"
  set ctx [:wf_context]
  set container [$ctx wf_container]
  if {$ctx ne $container} {
    $ctx forward load_form $container %proc $ctx
  }
  set :QM [$container set QM]

  ${container}::Property return_url -default "" -allow_query_parameter true

  if {${:state} eq "done"} {
    set done_actions republish
    set combined_form_info [${:QM} combined_question_form [self]]

    #
    # We could allow open_submission_review only when autograde is
    # possible, but apparently, it makes as well sense for other
    # open text answers
    #
    lappend done_actions open_submission_review
    #if {[dict get $combined_form_info autograde]} {
    #  lappend done_actions open_submission_review
    #}
    set swa_done_actions [concat $done_actions restart]

    ${container}::done actions $done_actions
    ${container}::done in_role swa [subst {
      -actions {$swa_done_actions}
    }]

  } elseif {${:state} eq "created" && [:property realexam 0]} {
    #
    # Check, if randomization is OK. If not, remove the "publish"
    # button from the workflow.
    #
    # Note: this initialization code is always called when the
    # workflow is initialized, which might not be wanted, when this
    # happen during e.g. a test-run of an instance. so, maybe put this
    # to some "render" method?
    #
    #ns_log notice "==== check for randomization"
    set combined_form_info [${:QM} combined_question_form [self]]
    set randomizationOk [dict get $combined_form_info randomization_for_exam]
    #ns_log notice "==== check for randomization DONE"
    ${container}::${:state} actions \
        [expr {$randomizationOk ? {publish restart} : {restart}}]
  }

  #
  # Unset the actual query return_url, since we want to use it via
  # property.  In some cases, we have to set it explicitly from the
  # property, e.g. in www-delete.
  #
  ::xo::cc unset_query_parameter return_url

  ########################################################################
  # web-callable method "delete"
  #
  # Delete the workflow instance and all its associated data.
  #
  :proc www-delete {} {
    ::xo::cc set_query_parameter return_url [:property return_url]
    xowf::test_item::answer_manager delete_all_answer_data [self]
    next
  }

  ########################################################################
  # web-callable method "print-answer-table"
  #
  # Print the answers in a tabular form.
  #
  :proc www-print-answer-table {} {
    set HTML ""
    set withAnswerColumns [${:package_id} query_parameter with_answers:boolean 0]

    set wf [xowf::test_item::answer_manager get_answer_wf [self]]
    if {$wf ne ""} {
      #set form_info [${:QM} combined_question_form -with_numbers [self]]

      set items [xowf::test_item::answer_manager get_wf_instances $wf]
      set items2 [$items deep_copy]
      foreach i [$items2 children] {
        $i set online-exam-userName [acs_user::get_element -user_id [$i creation_user] -element username]
        $i set online-exam-fullName [::xo::get_user_name [$i creation_user]]
      }
      set HTML [::xowf::test_item::answer_manager results_table \
                    -package_id ${:package_id} \
                    -items $items2 \
                    -state * \
                    -with_answers $withAnswerColumns \
                    [self]]
      $items2 destroy
    }
    if {$HTML eq ""} {
      set HTML "#xowiki.no_data#"
    } else {
      set HTML "<h1>#xowf.online-exam-results-table#</h1>$HTML"
    }
    set return_url [[$wf package_id] query_parameter local_return_url:localurl [:pretty_link]]
    append HTML "<hr><p><a class='btn btn-default' href='$return_url'>#xowiki.back#</a></p>\n"

    xo::Page requireCSS /resources/xowf/test-item.css
    :www-view $HTML
  }

  ########################################################################
  # web-callable method "print-participants"
  #
  # Print participants in a tabular form.
  #
  :proc www-print-participants {} {
    set HTML ""
    set wf [xowf::test_item::answer_manager get_answer_wf [self]]
    if {$wf ne ""} {
      set items [xowf::test_item::answer_manager get_wf_instances $wf]
      set items2 [$items deep_copy]
      foreach i [$items2 children] {
        $i set online-exam-userName [acs_user::get_element -user_id [$i creation_user] -element username]
        $i set online-exam-fullName [::xo::get_user_name [$i creation_user]]
      }
      set HTML [::xowf::test_item::answer_manager participants_table \
                    -package_id ${:package_id} \
                    -items $items2 \
                    -state * \
                    [self]]
      $items2 destroy
    }
    if {$HTML eq ""} {
      set HTML "#xowiki.no_data#"
    } else {
      set HTML "<h3>#xowf.Participants#</h3>$HTML"
    }
    set return_url [[$wf package_id] query_parameter local_return_url:localurl [:pretty_link]]
    append HTML "<hr><p><a class='btn btn-default' href='$return_url'>#xowiki.back#</a></p>\n"

    :www-view $HTML

  }

  ########################################################################
  # web-callable method "view-my-exam "
  #
  # Provide feedback to the student about the results.
  #
  :proc www-view-my-exam {} {
    if {${:state} eq "submission_review"} {
      ::xo::cc set_query_parameter creation_user [ad_conn user_id]
      ::xo::cc set_query_parameter as_student 1
      :www-print-answers
    } else {
      :www-view "#xowf.Exam-review-not-open#"
    }
  }

  ########################################################################
  # web-callable method "exam-summary"
  #
  # Print a summary of the exam-questions.
  #
  :proc www-exam-summary {} {
    :www-view [${:QM} exam_summary [self]]
  }

  ########################################################################
  # web-callable method "exam-results"
  #
  # export results as CSV table
  #
  :proc www-exam-results {} {
    set manual_gradings [:property manual_gradings]
    set results [:property __results]
    xowf::test_item::answer_manager results_export -reply -manual_gradings $manual_gradings $results
    ad_script_abort
  }


  ########################################################################
  # web-callable method "print-answers"
  #
  # Print the answers in a somewhat printer friendly way.
  #
  :proc www-print-answers {} {
    template::head::add_link -rel stylesheet -href /resources/xowf/test-item.css

    set as_student [:query_parameter as_student:boolean false]
    set d [xowf::test_item::answer_manager render_answers \
               -as_student    $as_student \
               -filter_id     [:query_parameter id:int32 ""] \
               -creation_user [:query_parameter creation_user:int32 ""] \
               -revision_id   [:query_parameter rid:int32 ""] \
               -form_objs     [:query_parameter fos:int32 ""] \
               -export        [:query_parameter export:boolean 0] \
               -orderby       [:query_parameter orderby:token "online-exam-userName"] \
               -grading       [:query_parameter grading:alnum [:property grading]] \
               -with_grading_table [expr {!$as_student}] \
               [self]]

    set do_stream [dict get $d do_stream]
    set HTML [dict get $d HTML]

    if {$do_stream == 0 && $HTML eq ""} {
      set HTML "#xowiki.no_data#"
    }

    if {!$as_student} {
      set return_url [:query_parameter local_return_url:localurl [:pretty_link]]
      append HTML "<hr><p><a class='btn btn-default' href='$return_url'>#xowiki.back#</a></p>\n"
    }

    if {$do_stream} {
      ns_write [lang::util::localize $HTML]
      set HTML ""
      ${:package_id} set __continuation ad_progress_bar_end
      return ""
    } else {
      :www-view $HTML
    }
  }



  ########################################################################
  # web-callable method "answer"
  #
  :proc www-answer {} {
    #
    # Create or use an answering workflow for the current exam. This
    # is a convenience routine to shorten the published URL.
    #
    # Make sure that no-one tries to start the answer workflow in a
    # state different to "published".
    #
    if {[:property _state] ne "published"} {
      :util_user_message -html -message "Cannot start answer workflow in this state"
    } else {
      set wf [xowf::test_item::answer_manager get_answer_wf [self]]
      set proctoring [:property proctoring]
      if {$proctoring ne "" && $proctoring} {
        set po [:property proctoring_options]
        set record_p [:property proctoring_record true]
        set cLink [export_vars -base [:pretty_link] {
          {m proctor}
          {link "[:pretty_link -query m=proctor-answer&proctoring_options=$po&record_p=$record_p]"}
        }]
        ::${:package_id} returnredirect $cLink
      } else {
        $wf www-create-or-use -parent_id [:item_id]
      }
    }
  }


  ########################################################################
  # web-callable function "qrcode", acts as responder
  #
  :proc www-qrcode {} {
    #
    # Produce a QR code with an answer link
    #
    set aLink [:pretty_link -absolute true -query m=answer]
    set fn /tmp/qr-${:item_id}.png
    exec qrencode -o $fn -l h $aLink
    ns_returnfile 200 image/png $fn
    ad_script_abort
  }

  ########################################################################
  # web-callable method "proctoring-display"
  #
  :proc www-proctoring-display {} {
    #
    # Display the proctoring files collected for this exam using the
    # UI by the proctoring-support package.
    #
    # By this is also possible to delete the proctoring files, either
    # for the whole exam or for the single participant.
    #

    ${:package_id} return_page -adp /packages/proctoring-support/lib/proctoring-display -variables {
        {object_id ${:item_id}}
    }
  }

  ########################################################################
  # web-callable function "proctor-answer"
  #
  :proc www-proctor-answer {} {
    #
    # Start answering an exam in proctored mode
    #
    if {[:property _state] ne "published"} {
      :util_user_message -html -message "Cannot start answer workflow in this state"
    } else {
      set wf [xowf::test_item::answer_manager get_answer_wf [self]]
      $wf www-create-or-use -parent_id [:item_id]
    }
  }

  ########################################################################
  # web-callable function "proctor"
  #
  :proc www-proctor {} {
    #
    # Redirect the exam to an iframe for implementing proctoring.  The
    # basic idea is that the web application turns on the camera and
    # keeps the iframe while the user is iterating through the exam.
    # The line "<h1>You are being proctored!</h1>" is just a
    # placeholder and has to be replaced with real code.
    #
    set link [:query_parameter link:localurl ""]

    ::xo::cc set_parameter template_file view-plain-master
    ::xo::cc set_parameter MenuBar 0

    set proctoring_template /packages/proctoring-support/lib/proctored-page
    if {[file exists [acs_root_dir]${proctoring_template}.adp]} {
      set object_id ${:item_id}
      set object_url $link
      set examination_statement_p [expr {![string match *p.try_out_mode=1* $link]}]
      set record_p [:property proctoring_record true]
      set proctoring_options [:property proctoring_options "d c a s"]
      foreach \
          proctoring_parm {d c a s} \
          flag {desktop_p camera_p audio_p examination_statement_p} {
        set $flag [expr {$proctoring_parm in $proctoring_options}]
      }
      set preview_p [expr {$desktop_p || $camera_p || $audio_p}]

      #
      # Set the max interval between screen captures to 30s (default is 60s)
      #
      set max_ms_interval 30000

      ${:package_id} return_page -adp $proctoring_template -variables {
        object_id
        object_url
        preview_p
        desktop_p
        camera_p
        audio_p
        record_p
        max_ms_interval
        examination_statement_p
        {check_active_p false}
      }
    } else {
      #
      # Minimal fallback in case the proctoring-support is not installed
      #
      return [:www-view [subst {
        <!-- ... proctor::start_dialog... -->
        <h1>You ([xo::cc user_id]) are being proctored in exam ${:object_id}!</h1>
        <iframe src="$link" width="100%" height="600"></iframe>
      }]]
    }
  }

  ########################################################################
  # web-callable function "proctor-image", acts as responder
  #
  :proc www-proctor-image {} {
    #
    # View a proctored image
    #
    set type [${:package_id} query_parameter type:ascii ""]
    set ts   [${:package_id} query_parameter ts:integer ""]
    set ext  [${:package_id} query_parameter e:wordchar ""]
    set user_id [${:package_id} query_parameter user_id:int32 ""]
    set proctoring_dir [proctoring::folder \
                            -object_id ${:item_id} \
                            -user_id $user_id]
    set png_path $proctoring_dir/$type-$ts.$ext
    #ns_log notice "image: $png_path ... [ad_file exists $$png_path]"
    ns_returnfile 200 [ns_guesstype $ts.$ext] $png_path
    ad_script_abort
  }

  ########################################################################
  # web-callable function "blank-inputs"
  #
  :proc www-blank-inputs {} {
    #
    # Analyze the student submissions an find situations, where input
    # is "cleared" between revisions.
    #
    template::head::add_link -rel stylesheet -href /resources/xowf/test-item.css
    set HTML [xowf::test_item::answer_manager render_answers_with_edit_history [self]]

    if {$HTML eq ""} {
      set HTML "#xowiki.no_data#"
    }
    set return_url [:query_parameter local_return_url:localurl [:pretty_link]]
    append HTML "<hr><p><a class='btn btn-default' href='$return_url'>#xowiki.back#</a></p>\n"

    :www-view $HTML
  }


  ########################################################################
  # AJAX call "poll", acts as responder
  #
  :proc www-poll {} {
    #
    # Return statistics about working and finished exams.
    #
    set wf [xowf::test_item::answer_manager get_answer_wf [self]]
    set answers [xowf::test_item::answer_manager get_answers $wf]
    set answered [xowf::test_item::answer_manager get_answers -state done $wf]
    ns_return 200 text/plain [llength $answered]/[llength $answers]
    #ns_log notice "MASTER POLL [self] ${:name}, returned [llength $answered]/[llength $answers]"
    ad_script_abort
  }

  ########################################################################
  # AJAX call "send-participant-message", acts as responder
  #
  :proc www-send-participant-message {} {
    #
    # Send a message to a participant
    #
    ::xowiki::includelet::personal-notification-messages message_add \
        -notification_id ${:item_id} \
        -to_user_id [${:package_id} form_parameter to_user_id ""] \
        -payload [list msg [${:package_id} form_parameter msg] \
                      from [xo::cc user_id] \
                      urgency [${:package_id} form_parameter urgency]]

    ns_return 200 text/plain ok
    ad_script_abort
  }

  ########################################################################
  # AJAX call "grade-single-item", acts as responder
  #
  :proc www-grade-single-item {} {
    set formDict [ns_set array [ns_getform]]

    #
    # Update property "manual_gradings" of the exam
    #
    set manual_gradings [:property manual_gradings]
    set user_id [dict get $formDict user_id]
    set qn [dict get $formDict question_name]
    dict set manual_gradings $user_id $qn achieved [dict get $formDict achieved]
    dict set manual_gradings $user_id $qn comment [dict get $formDict comment]
    dict set :instance_attributes manual_gradings $manual_gradings
    :update_attribute_from_slot [:find_slot instance_attributes] ${:instance_attributes}

    #
    # Recompute the achieved points percentage for the full exam
    # submission of the student... based on the grading scheme and
    # manual grading info.
    #
    set grading_scheme [dict get $formDict grading_scheme]
    set achieved_points [dict get $formDict achieved_points]
    set details [dict get $achieved_points details]
    set newDetails {}
    foreach detail $details {
      if {[dict get $detail attributeName] eq $qn} {
        dict set detail achieved [dict get $formDict achieved]
      }
      lappend newDetails $detail
    }
    dict set achieved_points details $newDetails
    dict set achieved_points achievedPoints ""
    set gradingInfo [::xowf::test_item::grading::$grading_scheme print -achieved_points $achieved_points]

    #
    # Return the line for the panel as result of the AJAX call
    #
    ns_return 200 text/plain [dict get $gradingInfo panel]
    ad_script_abort
  }

  #ns_log notice "==== object-specific inclass-exam [self] state ${:state} DONE (took [expr {[clock clicks -milliseconds]-$t0}]ms)"
}

#
# Local variables:
#    mode: tcl
#    tcl-indent-level: 2
#    indent-tabs-mode: nil
# End: