def get_clinical_text(self):
diagnoses = self.get_psychiatric_diagnoses() + \
self.get_medical_diagnoses()
return [
{
"heading": ws.webify(WSTRING("cpft_lps_dis_discharge_reason")),
"content": self.get_discharge_reason()
},
{
"heading": ws.webify(
WSTRING("cpft_lps_dis_referral_reason_t")),
"content": ", ".join(self.get_referral_reasons())
},
{
"heading": ws.webify(WSTRING("cpft_lps_dis_diagnoses_t")),
"content": ", ".join(diagnoses)
},
{
"heading": ws.webify(WSTRING("cpft_lps_dis_management_t")),
"content": ", ".join(self.get_managements())
},
{
"heading": ws.webify(WSTRING("cpft_lps_dis_outcome_t")),
"content": self.outcome
},
]
def get_clinical_text(self):
fielddictlist = []
items = self.get_items()
for item in items:
fielddictlist.append({
"content": u"<b>{}</b>: {}".format(ws.webify(item.code),
ws.webify(item.description))
})
return fielddictlist
def get_psychiatric_diagnoses(self):
psychiatric_diagnoses = [
WSTRING("cpft_lps_dis_diagnosis_no_active_mental_health_problem")
] if self.diagnosis_no_active_mental_health_problem else []
for i in range(1, 4 + 1): # magic number
if getattr(self, "diagnosis_psych_" + str(i) + "_icd10code"):
psychiatric_diagnoses.append(
ws.webify(getattr(self, "diagnosis_psych_" +
str(i) + "_icd10code"))
+ u" – "
+ ws.webify(getattr(self, "diagnosis_psych_" +
str(i) + "_description"))
)
return psychiatric_diagnoses
def get_task_html(self):
score = self.total_score()
h = u"""
<div class="summary">
<table class="summary">
"""
h += self.get_is_complete_tr()
h += tr(WSTRING("total_score"), answer(score) + " / 63")
h += u"""
</table>
</div>
<div class="explanation">
All questions are scored from 0–3
(0 free of symptoms, 3 most symptomatic).
</div>
<table class="taskdetail">
<tr>
<th width="70%">Question</th>
<th width="30%">Answer</th>
</tr>
"""
h += tr_qa(WSTRING("bdi_which_scale"), ws.webify(self.bdi_scale))
for q in xrange(1, Bdi.NQUESTIONS + 1):
h += tr_qa(u"{} {}".format(WSTRING("question"), q), getattr(self, "q" + str(q)))
h += (
u"""
</table>
"""
+ DATA_COLLECTION_ONLY_DIV
)
return h
def get_medical_diagnoses(self):
medical_diagnoses = []
for i in range(1, 4 + 1): # magic number
if getattr(self, "diagnosis_medical_" + str(i)):
medical_diagnoses.append(
ws.webify(getattr(self, "diagnosis_medical_" + str(i))))
return medical_diagnoses
def get_html_table_row(self):
return (u"<tr>" + u"<td>{}</td>" * 13 + u"</th>").format(
self.trial,
self.trial_ignoring_catch_trials,
self.target_presented,
self.target_time,
ws.number_to_dp(self.intensity, DP),
self.choice_time,
self.responded,
self.response_time,
self.response_latency_ms,
self.yes,
self.no,
ws.webify(self.caught_out_reset),
ws.webify(self.trial_num_in_calculation_sequence)
)
def get_note_as_html(self):
"""Return an HTML-formatted version of the note."""
return u"[{dt}, {user}]<br><b>{note}</b>".format(
dt=self.note_at or "?",
user=self.user or "?",
note=ws.webify(self.note) or "",
)
def get_html_table_rows(self):
return u"""
<tr class="subheading"><td>Photo {}: <b>{}</b></td></tr>
<tr><td>{}</td></tr>
""".format(
self.seqnum + 1, ws.webify(self.description),
self.get_blob_png_html(),
)
def get_task_html(self):
h = (
self.get_standard_clinician_block()
+ u"""
<table class="taskdetail">
<tr>
<td width="33%">Location:</td>
<td width="67%"><b>{}</b></td>
</tr>
""".format(
ws.webify(self.location)
)
)
h += tr_qa("Start:", format_datetime_string(self.start, DATEFORMAT.SHORT_DATETIME, None))
h += tr_qa("End:", format_datetime_string(self.end, DATEFORMAT.SHORT_DATETIME, None))
h += tr(italic("Calculated duration (hours:minutes)"), italic(get_duration_h_m(self.start, self.end)))
h += tr_qa("Patient contact?", get_yes_no_none(self.patient_contact))
h += tr_qa("Staff liaison?", get_yes_no_none(self.staff_liaison))
h += tr_qa("Other liaison?", get_yes_no_none(self.other_liaison))
h += tr_qa("Comment:", ws.webify(self.comment))
return h
def get_clinical_text(self):
if not self.is_complete():
return CTV_DICTLIST_INCOMPLETE
dl = [{
"content": "Pertains to: {}. Category: {}.".format(
format_datetime_string(self.date_pertains_to,
DATEFORMAT.LONG_DATE),
self.get_description()
)
}]
if self.comments:
dl.append({"content": ws.webify(self.comments)})
return dl
def get_task_html(self):
return self.get_standard_clinician_block() + u"""
<table class="taskdetail">
<tr class="subheading"><td>Description</td></tr>
<tr><td>{}</td></tr>
<tr class="subheading"><td>Photo</td></tr>
<tr><td>{}</td></tr>
</table>
""".format(
answer(ws.webify(self.description), default="(No description)",
default_for_blank_strings=True),
# ... xhtml2pdf crashes if the contents are empty...
self.get_blob_png_html(self.photo_blobid, self.rotation)
)
def get_task_html(self):
# Avoid tables - PDF generator crashes if text is too long.
h = self.get_standard_clinician_block() + u"""
<div class="heading">
{heading_location}
</div>
<div>
{location}
</div>
<div class="heading">
{heading_note}
</div>
<div>
{note}
</div>
""".format(
heading_location=WSTRING("location"),
location=answer(ws.webify(self.location),
default_for_blank_strings=True),
heading_note=WSTRING("progressnote_note"),
note=answer(ws.webify(self.note), default_for_blank_strings=True),
)
return h
def get_current_user_html(self, offer_main_menu=True):
"""HTML showing current database/user, +/- link to main menu."""
if self.user:
user = "******".format(ws.webify(self.user))
else:
user = ""
database = cc_html.get_database_title_string()
if offer_main_menu:
menu = """ <a href="{}">Return to main menu</a>.""".format(
cc_html.get_url_main_menu())
else:
menu = ""
if not user and not database and not menu:
return ""
return "<div>{} {}{}</div>".format(database, user, menu)
def get_clinical_text(self):
if not self.is_complete():
return CTV_DICTLIST_INCOMPLETE
c = self.meets_general_criteria()
if c is None:
category = "Unknown if met or not met"
elif c:
category = "Met"
else:
category = "Not met"
dl = [{
"content": "Pertains to: {}. General criteria for "
"schizophrenia: {}.".format(
format_datetime_string(self.date_pertains_to,
DATEFORMAT.LONG_DATE),
category)
}]
if self.comments:
dl.append({"content": ws.webify(self.comments)})
return dl
def get_filter_html(filter_name,
filter_value,
clear_action,
apply_field_html,
apply_action,
filter_list):
"""HTML to view or change a filter."""
# returns: found a filter?
no_filter_value = (
filter_value is None
or (
isinstance(filter_value, basestring)
and not filter_value
)
)
if no_filter_value:
filter_list.append(u"""
{filter_name}: {apply_field_html}
<br>
""".format(
filter_name=filter_name,
apply_field_html=apply_field_html,
# apply_action=apply_action,
))
# <input type="submit" name="{apply_action}" value="Filter">
return False
else:
filter_list.append(u"""
{filter_name}: <b>{filter_value}</b>
<input type="submit" name="{clear_action}" value="Clear">
{apply_field_html}
<br>
""".format(
filter_name=filter_name,
filter_value=ws.webify(filter_value),
clear_action=clear_action,
apply_field_html=apply_field_html,
# apply_action=apply_action
))
# <input type="submit" name="{apply_action}" value="Filter">
return True
def get_ctv_subheading(self, wstringname):
return {
"subheading": ws.webify(WSTRING(wstringname)),
"skip_if_no_content": False
}
def get_task_html(self):
DICTQ1 = {None: None}
DICTQ3 = {None: None}
DICTQ4 = {None: None}
DICTQ5 = {None: None}
DICTQ11 = {None: None}
DICTQ12 = {None: None}
for option in range(1, 5):
DICTQ1[option] = WSTRING("gmcpq_q1_option" + str(option))
for option in range(1, 6):
DICTQ3[option] = WSTRING("gmcpq_q3_option" + str(option))
DICTQ11[option] = WSTRING("gmcpq_q11_option" + str(option))
for option in range(0, 6):
prefix = str(option) + u" – " if option > 0 else ""
DICTQ4[option] = prefix + WSTRING("gmcpq_q4_option" + str(option))
DICTQ5[option] = prefix + WSTRING("gmcpq_q5_option" + str(option))
for option in range(1, 17):
DICTQ12[option] = WSTRING("gmcpq_ethnicity_option" + str(option))
h = u"""
<div class="summary">
<table class="summary">
{}
</table>
</div>
<table class="taskdetail">
<tr>
<th width="60%">Question</th>
<th width="40%">Answer</th>
</tr>
""".format(self.get_is_complete_tr())
ell = "… " # horizontal ellipsis
sep_row = subheading_spanning_two_columns("")
blank_cell = td("", td_class="subheading")
h += tr_qa(WSTRING("gmcpq_q_doctor"), ws.webify(self.doctor))
h += sep_row
h += tr_qa(WSTRING("gmcpq_q1"), get_from_dict(DICTQ1, self.q1))
h += tr(td(WSTRING("gmcpq_q2")), blank_cell, literal=True)
h += tr_qa(ell + WSTRING("gmcpq_q2_a"), get_yes_no_none(self.q2a))
h += tr_qa(ell + WSTRING("gmcpq_q2_b"), get_yes_no_none(self.q2b))
h += tr_qa(ell + WSTRING("gmcpq_q2_c"), get_yes_no_none(self.q2c))
h += tr_qa(ell + WSTRING("gmcpq_q2_d"), get_yes_no_none(self.q2d))
h += tr_qa(ell + WSTRING("gmcpq_q2_e"), get_yes_no_none(self.q2e))
h += tr_qa(ell + WSTRING("gmcpq_q2_f"), get_yes_no_none(self.q2f))
h += tr_qa(ell + ell + WSTRING("gmcpq_q2f_s"),
ws.webify(self.q2f_details))
h += tr_qa(WSTRING("gmcpq_q3"), get_from_dict(DICTQ3, self.q3))
h += tr(td(WSTRING("gmcpq_q4")), blank_cell, literal=True)
h += tr_qa(ell + WSTRING("gmcpq_q4_a"),
get_from_dict(DICTQ4, self.q4a))
h += tr_qa(ell + WSTRING("gmcpq_q4_b"),
get_from_dict(DICTQ4, self.q4b))
h += tr_qa(ell + WSTRING("gmcpq_q4_c"),
get_from_dict(DICTQ4, self.q4c))
h += tr_qa(ell + WSTRING("gmcpq_q4_d"),
get_from_dict(DICTQ4, self.q4d))
h += tr_qa(ell + WSTRING("gmcpq_q4_e"),
get_from_dict(DICTQ4, self.q4e))
h += tr_qa(ell + WSTRING("gmcpq_q4_f"),
get_from_dict(DICTQ4, self.q4f))
h += tr_qa(ell + WSTRING("gmcpq_q4_g"),
get_from_dict(DICTQ4, self.q4g))
h += tr(td(WSTRING("gmcpq_q5")), blank_cell, literal=True)
h += tr_qa(ell + WSTRING("gmcpq_q5_a"),
get_from_dict(DICTQ5, self.q5a))
h += tr_qa(ell + WSTRING("gmcpq_q5_b"),
get_from_dict(DICTQ5, self.q5b))
h += tr_qa(WSTRING("gmcpq_q6"), get_yes_no_none(self.q6))
h += tr_qa(WSTRING("gmcpq_q7"), get_yes_no_none(self.q7))
h += tr_qa(WSTRING("gmcpq_q8"), get_yes_no_none(self.q8))
h += tr_qa(WSTRING("gmcpq_q9_s"), ws.webify(self.q9))
h += sep_row
h += tr_qa(WSTRING("sex"), ws.webify(self.q10))
h += tr_qa(WSTRING("gmcpq_q11"), get_from_dict(DICTQ11, self.q11))
h += tr_qa(WSTRING("gmcpq_q12"), get_from_dict(DICTQ12, self.q12))
h += tr_qa(ell + WSTRING("gmcpq_ethnicity_other_s"),
ws.webify(self.q12_details))
h += u"""
</table>
"""
return h
def get_task_html(self):
h = self.get_standard_clinician_block(True, self.comments) + u"""
<div class="summary">
<table class="summary">
""" + self.get_is_complete_tr()
h += tr_qa(WSTRING("date_pertains_to"),
format_datetime_string(self.date_pertains_to,
DATEFORMAT.LONG_DATE, default=None))
h += tr_qa(WSTRING("icd10pd_meets_general_criteria"),
get_yes_no_none(self.hasPD()))
h += tr_qa(WSTRING("icd10_paranoid_pd_title"),
get_yes_no_none(self.hasParanoidPD()))
h += tr_qa(WSTRING("icd10_schizoid_pd_title"),
get_yes_no_none(self.hasSchizoidPD()))
h += tr_qa(WSTRING("icd10_dissocial_pd_title"),
get_yes_no_none(self.hasDissocialPD()))
h += tr_qa(WSTRING("icd10_eu_pd_i_title"),
get_yes_no_none(self.hasEUPD_I()))
h += tr_qa(WSTRING("icd10_eu_pd_b_title"),
get_yes_no_none(self.hasEUPD_B()))
h += tr_qa(WSTRING("icd10_histrionic_pd_title"),
get_yes_no_none(self.hasHistrionicPD()))
h += tr_qa(WSTRING("icd10_anankastic_pd_title"),
get_yes_no_none(self.hasAnankasticPD()))
h += tr_qa(WSTRING("icd10_anxious_pd_title"),
get_yes_no_none(self.hasAnxiousPD()))
h += tr_qa(WSTRING("icd10_dependent_pd_title"),
get_yes_no_none(self.hasDependentPD()))
h += u"""
</table>
</div>
<div>
<p><i>Vignette:</i></p>
<p>{}</p>
</div>
<table class="taskdetail">
<tr>
<th width="80%">Question</th>
<th width="20%">Answer</th>
</tr>
""".format(
answer(ws.webify(self.vignette), default_for_blank_strings=True)
)
# General
h += subheading_spanning_two_columns(WSTRING("icd10pd_general"))
h += self.get_twocol_bool_row_true_false("g1", WSTRING("icd10pd_G1"))
h += self.pd_b_text("icd10pd_G1b")
for i in range(1, Icd10SpecPD.N_GENERAL_1 + 1):
h += self.get_twocol_bool_row_true_false(
"g1_" + str(i), WSTRING("icd10pd_G1_" + str(i)))
for i in range(2, Icd10SpecPD.N_GENERAL + 1):
h += self.get_twocol_bool_row_true_false(
"g" + str(i), WSTRING("icd10pd_G" + str(i)))
# Paranoid, etc.
h += self.standard_pd_html("paranoid", Icd10SpecPD.N_PARANOID)
h += self.standard_pd_html("schizoid", Icd10SpecPD.N_SCHIZOID)
h += self.standard_pd_html("dissocial", Icd10SpecPD.N_DISSOCIAL)
# EUPD is special
h += self.pd_heading("icd10_eu_pd_title")
h += self.pd_skiprow("eu")
h += self.pd_general_criteria_bits()
h += self.pd_subheading("icd10_eu_pd_i_title")
h += self.pd_b_text("icd10_eu_pd_i_B")
for i in range(1, Icd10SpecPD.N_EUPD_I + 1):
h += self.pd_basic_row("eu", i)
h += self.pd_subheading("icd10_eu_pd_b_title")
h += self.pd_b_text("icd10_eu_pd_b_B")
for i in range(Icd10SpecPD.N_EUPD_I + 1, Icd10SpecPD.N_EU + 1):
h += self.pd_basic_row("eu", i)
# Back to plain ones
h += self.standard_pd_html("histrionic", Icd10SpecPD.N_HISTRIONIC)
h += self.standard_pd_html("anankastic", Icd10SpecPD.N_ANANKASTIC)
h += self.standard_pd_html("anxious", Icd10SpecPD.N_ANXIOUS)
h += self.standard_pd_html("dependent", Icd10SpecPD.N_DEPENDENT)
# Done
h += u"""
</table>
""" + ICD10_COPYRIGHT_DIV
return h
def add_user(form):
"""Add a user, and return HTML success/failure message."""
username = ws.get_cgi_parameter_str(form, PARAM.USERNAME)
password_1 = ws.get_cgi_parameter_str(form, PARAM.PASSWORD_1)
password_2 = ws.get_cgi_parameter_str(form, PARAM.PASSWORD_2)
must_change_password = ws.get_cgi_parameter_bool(
form, PARAM.MUST_CHANGE_PASSWORD)
may_use_webviewer = ws.get_cgi_parameter_bool(
form, PARAM.MAY_USE_WEBVIEWER)
may_view_other_users_records = ws.get_cgi_parameter_bool(
form, PARAM.MAY_VIEW_OTHER_USERS_RECORDS)
view_all_patients_when_unfiltered = ws.get_cgi_parameter_bool(
form, PARAM.VIEW_ALL_PTS_WHEN_UNFILTERED)
may_upload = ws.get_cgi_parameter_bool(form, PARAM.MAY_UPLOAD)
superuser = ws.get_cgi_parameter_bool(form, PARAM.SUPERUSER)
may_register_devices = ws.get_cgi_parameter_bool(
form, PARAM.MAY_REGISTER_DEVICES)
may_use_webstorage = ws.get_cgi_parameter_bool(
form, PARAM.MAY_USE_WEBSTORAGE)
may_dump_data = ws.get_cgi_parameter_bool(form, PARAM.MAY_DUMP_DATA)
may_run_reports = ws.get_cgi_parameter_bool(form, PARAM.MAY_RUN_REPORTS)
may_add_notes = ws.get_cgi_parameter_bool(form, PARAM.MAY_ADD_NOTES)
user = User(username, False)
if user.user:
return user_management_failure_message(
"User already exists: " + username)
if not is_username_permissible(username):
return user_management_failure_message(
"Invalid username: "******"Passwords don't mach")
if len(password_1) < MINIMUM_PASSWORD_LENGTH:
return user_management_failure_message(
"Password must be at least {} characters".format(
MINIMUM_PASSWORD_LENGTH
))
user = User(username, True)
user.set_password(password_1)
user.may_use_webviewer = may_use_webviewer
user.may_view_other_users_records = may_view_other_users_records
user.view_all_patients_when_unfiltered = view_all_patients_when_unfiltered
user.may_upload = may_upload
user.superuser = superuser
user.may_register_devices = may_register_devices
user.may_use_webstorage = may_use_webstorage
user.may_dump_data = may_dump_data
user.may_run_reports = may_run_reports
user.may_add_notes = may_add_notes
user.save()
if must_change_password:
user.force_password_change()
audit(
(
"User created: {}: "
"may_use_webviewer={}, "
"may_view_other_users_records={}, "
"view_all_patients_when_unfiltered={}, "
"may_upload={}, "
"superuser={}, "
"may_register_devices={}, "
"may_use_webstorage={}, "
"may_dump_data={}, "
"may_run_reports={}, "
"may_add_notes={}, "
"must_change_password={}"
).format(
user.user,
may_use_webviewer,
may_view_other_users_records,
view_all_patients_when_unfiltered,
may_upload,
superuser,
may_register_devices,
may_use_webstorage,
may_dump_data,
may_run_reports,
may_add_notes,
must_change_password
)
)
return user_management_success_message("User " + user.user + " created")
def manage_users(session):
"""HTML to view/edit users."""
allusers = pls.db.fetch_all_objects_from_db(User, User.TABLENAME,
User.FIELDS, True)
allusers = sorted(allusers, key=lambda k: k.user)
output = pls.WEBSTART + u"""
{}
<h1>Manage users</h1>
<ul>
<li><a href="{}">Add user</a></li>
</ul>
<table>
<tr>
<th>User name</th>
<th>Actions</th>
<th>Locked out?</th>
<th>Last password change (UTC)</th>
<th>May use web viewer?</th>
<th>May view other users’ records?</th>
<th>Sees all patients’ records when unfiltered?</th>
<th>May upload data?</th>
<th>May manage users?</th>
<th>May register tablet devices?</th>
<th>May use webstorage?</th>
<th>May dump data?</th>
<th>May run reports?</th>
<th>May add notes?</th>
<th>Click to delete use</th>
</tr>
""".format(
session.get_current_user_html(),
cc_html.get_generic_action_url(ACTION.ASK_TO_ADD_USER),
) + cc_html.WEBEND
for u in allusers:
if u.is_locked_out():
enableuser = "******".format(
get_url_enable_user(u.user)
)
lockedmsg = "Yes, until {}".format(cc_dt.format_datetime(
u.locked_out_until(),
DATEFORMAT.ISO8601
))
else:
enableuser = ""
lockedmsg = "No"
output += u"""
<tr>
<td>{username}</td>
<td>
<a href="{url_edit}">Edit permissions</a>
| <a href="{url_changepw}">Change password</a>
{enableuser}
</td>
<td>{lockedmsg}</td>
<td>{lastpwchange}</td>
<td>{may_use_webviewer}</td>
<td>{may_view_other_users_records}</td>
<td>{view_all_patients_when_unfiltered}</td>
<td>{may_upload}</td>
<td>{superuser}</td>
<td>{may_register_devices}</td>
<td>{may_use_webstorage}</td>
<td>{may_dump_data}</td>
<td>{may_run_reports}</td>
<td>{may_add_notes}</td>
<td><a href="{url_delete}">Delete user {username}</a></td>
</tr>
""".format(
url_edit=get_url_edit_user(u.user),
url_changepw=cc_html.get_url_enter_new_password(u.user),
enableuser=enableuser,
lockedmsg=lockedmsg,
lastpwchange=ws.webify(u.last_password_change_utc),
may_use_webviewer=cc_html.get_yes_no(u.may_use_webviewer),
may_view_other_users_records=cc_html.get_yes_no(
u.may_view_other_users_records),
view_all_patients_when_unfiltered=cc_html.get_yes_no(
u.view_all_patients_when_unfiltered),
may_upload=cc_html.get_yes_no(u.may_upload),
superuser=cc_html.get_yes_no(u.superuser),
may_register_devices=cc_html.get_yes_no(u.may_register_devices),
may_use_webstorage=cc_html.get_yes_no(u.may_use_webstorage),
may_dump_data=cc_html.get_yes_no(u.may_dump_data),
may_run_reports=cc_html.get_yes_no(u.may_run_reports),
may_add_notes=cc_html.get_yes_no(u.may_add_notes),
url_delete=get_url_ask_delete_user(u.user),
username=u.user,
)
output += u"""
</table>
""" + cc_html.WEBEND
return output
def WXSTRING(taskname, stringname, default=None):
"""Returns a web-safe version of an XSTRING (see above)."""
return ws.webify(XSTRING(taskname, stringname, default))
def get_current_filter_html(self):
"""HTML showing current filters and offering ways to set them."""
# Consider also multiple buttons in a single form:
# http://stackoverflow.com/questions/942772
# ... might allow "apply all things entered here" button
# ... HOWEVER, I think this would break the ability to press Enter
# after entering information in any box (which is nice).
found_one = False
filters = []
id_filter_values = []
id_filter_descs = []
for n in range(1, NUMBER_OF_IDNUMS + 1):
nstr = str(n)
id_filter_values.append(getattr(self, "filter_idnum" + nstr))
id_filter_descs.append(pls.get_id_desc(n))
id_filter_value = None
id_filter_name = "ID number"
for index, value in enumerate(id_filter_values):
if value is not None:
id_filter_value = value
id_filter_name = id_filter_descs[index]
which_idnum_temp = u"""
{picker}
<input type="number" name="{PARAM.IDNUM_VALUE}">
""".format(
picker=cc_html.get_html_which_idnum_picker(PARAM.WHICH_IDNUM),
PARAM=PARAM,
)
found_one = get_filter_html(
id_filter_name,
id_filter_value,
ACTION.CLEAR_FILTER_IDNUMS,
which_idnum_temp,
ACTION.APPLY_FILTER_IDNUMS,
filters
) or found_one
found_one = get_filter_html(
"Surname",
self.filter_surname,
ACTION.CLEAR_FILTER_SURNAME,
"""<input type="text" name="{}">""".format(PARAM.SURNAME),
ACTION.APPLY_FILTER_SURNAME,
filters
) or found_one
found_one = get_filter_html(
"Forename",
self.filter_forename,
ACTION.CLEAR_FILTER_FORENAME,
"""<input type="text" name="{}">""".format(PARAM.FORENAME),
ACTION.APPLY_FILTER_FORENAME,
filters
) or found_one
found_one = get_filter_html(
"Date of birth",
cc_dt.format_datetime(self.get_filter_dob(), DATEFORMAT.LONG_DATE),
ACTION.CLEAR_FILTER_DOB,
"""<input type="date" name="{}">""".format(PARAM.DOB),
ACTION.APPLY_FILTER_DOB,
filters
) or found_one
found_one = get_filter_html(
"Sex",
self.filter_sex,
ACTION.CLEAR_FILTER_SEX,
cc_html.get_html_sex_picker(param=PARAM.SEX,
selected=self.filter_sex,
offer_all=True),
ACTION.APPLY_FILTER_SEX,
filters
) or found_one
found_one = get_filter_html(
"Task type",
self.filter_task,
ACTION.CLEAR_FILTER_TASK,
cc_task.get_task_filter_dropdown(self.filter_task),
ACTION.APPLY_FILTER_TASK,
filters
) or found_one
found_one = get_filter_html(
"Task completed",
cc_html.get_yes_no_none(self.filter_complete),
ACTION.CLEAR_FILTER_COMPLETE,
"""
<select name="{PARAM.COMPLETE}">
<option value="">(all)</option>
<option value="1"{selected_1}>Complete</option>
<option value="0"{selected_0}>Incomplete</option>
</select>
""".format(PARAM=PARAM,
selected_1=ws.option_selected(self.filter_complete, 1),
selected_0=ws.option_selected(self.filter_complete, 0)),
ACTION.APPLY_FILTER_COMPLETE,
filters
) or found_one
found_one = get_filter_html(
"Include old (overwritten) versions",
cc_html.get_yes_no_none(self.filter_include_old_versions),
ACTION.CLEAR_FILTER_INCLUDE_OLD_VERSIONS,
"""
<select name="{PARAM.INCLUDE_OLD_VERSIONS}">
<option value="">(exclude)</option>
<option value="1"{y}>Include</option>
<option value="0"{n}>Exclude</option>
</select>
""".format(PARAM=PARAM,
y=ws.option_selected(self.filter_include_old_versions,
1),
n=ws.option_selected(self.filter_include_old_versions,
0)),
ACTION.APPLY_FILTER_INCLUDE_OLD_VERSIONS,
filters
) or found_one
found_one = get_filter_html(
"Tablet device",
self.filter_device,
ACTION.CLEAR_FILTER_DEVICE,
cc_device.get_device_filter_dropdown(self.filter_device),
ACTION.APPLY_FILTER_DEVICE,
filters
) or found_one
found_one = get_filter_html(
"Adding user",
self.filter_user,
ACTION.CLEAR_FILTER_USER,
"""<input type="text" name="{}">""".format(PARAM.USER),
ACTION.APPLY_FILTER_USER,
filters
) or found_one
found_one = get_filter_html(
"Start date (UTC)",
cc_dt.format_datetime(self.get_filter_start_datetime(),
DATEFORMAT.LONG_DATE),
ACTION.CLEAR_FILTER_START_DATETIME,
"""<input type="date" name="{}">""".format(PARAM.START_DATETIME),
ACTION.APPLY_FILTER_START_DATETIME,
filters
) or found_one
found_one = get_filter_html(
"End date (UTC)",
cc_dt.format_datetime(self.get_filter_end_datetime(),
DATEFORMAT.LONG_DATE),
ACTION.CLEAR_FILTER_END_DATETIME,
"""<input type="date" name="{}">""".format(PARAM.END_DATETIME),
ACTION.APPLY_FILTER_END_DATETIME,
filters
) or found_one
found_one = get_filter_html(
"Text contents",
ws.webify(self.filter_text),
ACTION.CLEAR_FILTER_TEXT,
"""<input type="text" name="{}">""".format(PARAM.TEXT),
ACTION.APPLY_FILTER_TEXT,
filters
) or found_one
clear_filter_html = u"""
<input type="submit" name="{ACTION.CLEAR_FILTERS}"
value="Clear all filters">
<br>
""".format(
ACTION=ACTION,
)
no_filters_applied = "<p><b><i>No filters applied</i></b></p>"
html = u"""
<form class="filter" method="POST" action="{script}">
<input type="hidden" name="{PARAM.ACTION}"
value="{ACTION.FILTER}">
<input type="submit" class="important"
name="{ACTION.APPLY_FILTERS}"
value="Apply new filters">
<br>
<!-- First submit button is default on pressing Enter,
which is why the Apply button is at the top of the form -->
{clearbutton}
{filters}
</form>
""".format(
script=pls.SCRIPT_NAME,
ACTION=ACTION,
PARAM=PARAM,
clearbutton=clear_filter_html if found_one else no_filters_applied,
filters="".join(filters),
)
return html
def get_clinical_text(self):
if not self.is_complete():
return CTV_DICTLIST_INCOMPLETE
return [{"content": u"{} total score {}/63".format(ws.webify(self.bdi_scale), self.total_score())}]
def get_clinical_text(self):
return [{"content": ws.webify(self.note)}]
def subsubhead_text(self, fieldname):
return self.subsubheading(fieldname) + u'<div><b>{}</b></div>'.format(
ws.webify(getattr(self, fieldname))
)
def WSTRING(stringname):
"""Returns a web-safe version of a string from the XML string file."""
return ws.webify(LSTRING(stringname))
def get_task_html(self):
score = self.total_score()
ANSWER_DICT = {None: "?"}
for option in range(0, 4):
ANSWER_DICT[option] = (
str(option) + u" — " + WSTRING("gass_option" + str(option)))
h = u"""
<div class="summary">
<table class="summary">
{}
<tr><td>{}</td><td><b>{}</b> / 63</td></tr>
</table>
</div>
<div class="explanation">
Ratings pertain to the past week.
</div>
<table class="taskdetail">
<tr>
<th width="65%">Question</th>
<th width="20%">Answer</th>
<th width="15%">Distressing?</th><
/tr>
""".format(
self.get_is_complete_tr(),
WSTRING("total_score"), score
)
h += self.get_group_html(Gass.list_sedation,
WSTRING("gass_group_sedation"),
ANSWER_DICT)
h += self.get_group_html(Gass.list_cardiovascular,
WSTRING("gass_group_cardiovascular"),
ANSWER_DICT)
h += self.get_group_html(Gass.list_epse,
WSTRING("gass_group_epse"),
ANSWER_DICT)
h += self.get_group_html(Gass.list_anticholinergic,
WSTRING("gass_group_anticholinergic"),
ANSWER_DICT)
h += self.get_group_html(Gass.list_gastrointestinal,
WSTRING("gass_group_gastrointestinal"),
ANSWER_DICT)
h += self.get_group_html(Gass.list_genitourinary,
WSTRING("gass_group_genitourinary"),
ANSWER_DICT)
if self.is_female():
h += self.get_group_html(Gass.list_prolactinaemic_female,
WSTRING("gass_group_prolactinaemic") +
" (" + WSTRING("female") + ")",
ANSWER_DICT)
else:
h += self.get_group_html(Gass.list_prolactinaemic_male,
WSTRING("gass_group_prolactinaemic") +
" (" + WSTRING("male") + ")",
ANSWER_DICT)
h += self.get_group_html(Gass.list_weightgain,
WSTRING("gass_group_weightgain"),
ANSWER_DICT)
h += u"""
<tr class="subheading"><td colspan="3">{}</td></tr>
<tr><td colspan="3">{}</td></tr>
</table>
""".format(
WSTRING("gass_medication_hint"),
ws.webify(self.medication)
)
return h
def get_html_table_row(self):
return tr(
self.seqnum + 1,
answer(ws.webify(self.code)),
answer(ws.webify(self.description)),
)
def get_task_html(self):
stagearray = self.get_stage_array()
trialarray = self.get_trial_array()
# THIS IS A NON-EDITABLE TASK, so we *ignore* the problem
# of matching to no-longer-current records.
# (See PhotoSequence.py for a task that does it properly.)
# Provide HTML
# HTML
h = u"""
<div class="summary">
<table class="summary">
{}
</table>
</div>
<div class="explanation">
1. Simple discrimination (SD), and 2. reversal (SDr);
3. compound discrimination (CD), and 4. reversal (CDr);
5. intradimensional shift (ID), and 6. reversal (IDr);
7. extradimensional shift (ED), and 8. reversal (EDr).
</div>
<table class="taskconfig">
<tr>
<th width="50%">Configuration variable</th>
<th width="50%">Value</th>
</tr>
""".format(
self.get_is_complete_tr(),
)
h += tr_qa(WSTRING("ided3d_last_stage"), self.last_stage)
h += tr_qa(WSTRING("ided3d_max_trials_per_stage"),
self.max_trials_per_stage)
h += tr_qa(WSTRING("ided3d_progress_criterion_x"),
self.progress_criterion_x)
h += tr_qa(WSTRING("ided3d_progress_criterion_y"),
self.progress_criterion_y)
h += tr_qa(WSTRING("ided3d_min_number"), self.min_number)
h += tr_qa(WSTRING("ided3d_max_number"), self.max_number)
h += tr_qa(WSTRING("ided3d_pause_after_beep_ms"),
self.pause_after_beep_ms)
h += tr_qa(WSTRING("ided3d_iti_ms"), self.iti_ms)
h += tr_qa(WSTRING("ided3d_counterbalance_dimensions")
+ u"<sup>[1]</sup>",
self.counterbalance_dimensions)
h += tr_qa(WSTRING("volume"), self.volume)
h += tr_qa(WSTRING("ided3d_offer_abort"), self.offer_abort)
h += tr_qa(WSTRING("ided3d_debug_display_stimuli_only"),
self.debug_display_stimuli_only)
h += tr_qa(u"Shapes (as a JSON-encoded array of SVG "
u"definitions; X and Y range both –60 to +60)",
ws.webify(self.shape_definitions_svg))
h += u"""
</table>
<table class="taskdetail">
<tr><th width="50%">Measure</th><th width="50%">Value</th></tr>
"""
h += tr_qa("Aborted?", get_yes_no_none(self.aborted))
h += tr_qa("Finished?", get_yes_no_none(self.finished))
h += tr_qa("Last trial completed", self.last_trial_completed)
h += (
u"""
</table>
<div>Stage specifications and results:</div>
"""
+ self.get_stage_html(stagearray)
+ u"<div>Trial-by-trial results:</div>"
+ self.get_trial_html(trialarray)
+ u"""
<div class="footnotes">
[1] Counterbalancing of dimensions is as follows, with
notation X/Y indicating that X is the first relevant
dimension (for stages SD–IDr) and Y is the second relevant
dimension (for stages ED–EDr).
0: shape/colour.
1: colour/number.
2: number/shape.
3: shape/number.
4: colour/shape.
5: number/colour.
</div>
"""
)
return h
def get_ctv_description_content(self, x):
return {
"description": ws.webify(WSTRING(x)),
"content": ws.webify(getattr(self, x))
}
