def from_other_phone(self, message, patient_id, text):
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond(_("Unknown patient %(id)s.") % {"id": patient_id})
return
if isinstance(message.reporter, Nurse):
""" this is an 'outcome' command from a nurse """
patient.related_messages.add(message.persistent_msg)
m = re.match("[0-9a-z]+", text)
if m is None:
# improperly formatted
logging.info(
"Nurse %s sent unrecognized command '%s'" % (message.reporter.alias, message.persistent_msg)
)
message.respond(_("Please report patient outcomes in the format 'patient-id outcome-code notes'"))
return
outcome_code = m.group(0)
try:
notes = text.strip("outcome_code")
outcome = patient.register_event(outcome_code, message.reporter, notes=notes)
except OutcomeType.DoesNotExist:
message.respond(_("Outcome (%(code)s) not recognized.") % {"code": outcome_code})
return
message.respond(_("Patient %(id)s updated to '%(code)s'") % {"id": patient_id, "code": outcome.name})
return
""" This is a message sent by a client from another phone """
message.reporter = patient
try:
func, groups = self.kw.match(None, text)
except TypeError:
# no matches found
self.other(message)
return
func(self, message, groups)
def from_other_phone(self, message, patient_id, text):
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond(_("Unknown patient %(id)s.") % {'id':patient_id})
return
if isinstance(message.reporter,Nurse):
""" this is an 'outcome' command from a nurse """
patient.related_messages.add(message.persistent_msg)
m = re.match('[0-9a-z]+', text)
if m is None:
# improperly formatted
logging.info("Nurse %s sent unrecognized command '%s'" % \
(message.reporter.alias, message.persistent_msg))
message.respond( _("Please report patient outcomes in the format 'patient-id outcome-code notes'") )
return
outcome_code = m.group(0)
try:
notes = text.strip('outcome_code')
outcome = patient.register_event(outcome_code, message.reporter, notes=notes)
except OutcomeType.DoesNotExist:
message.respond( _("Outcome (%(code)s) not recognized.")%{'code':outcome_code} )
return
message.respond( _("Patient %(id)s updated to '%(code)s'") % \
{'id':patient_id, 'code':outcome.name} )
return
""" This is a message sent by a client from another phone """
message.reporter = patient
try:
func,groups = self.kw.match(None, text)
except TypeError:
# no matches found
self.other(message)
return
func(self, message, groups)
def is_nurse_invalid(self, site_code):
if len(site_code) == 0:
return [_("Missing 'site_code'.") + NURSE_COMMAND ]
try:
Site.objects.get(code=site_code)
except Site.DoesNotExist:
return [_("Unknown sitecode %(code)s") % {"code" : site_code}]
return False
def is_nurse_invalid(self, site_code):
if len(site_code) == 0:
return [_("Missing 'site_code'. ") + NURSE_COMMAND ]
try:
Site.objects.get(code__iexact=site_code)
except Site.DoesNotExist:
response = _("Site %(code)s does not exist") % {"code": site_code }
return [response]
return False
def shida(self, message, problem_code, notes):
response = ""
try:
problem = message.reporter.register_event(problem_code, notes=notes)
except ProblemType.DoesNotExist:
response = _("Problem %(code)s not recognized. ") % {"code": problem_code}
problem = message.reporter.register_event(SHIDA_CODE)
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SHIDA_CODE))
message.respond(response + _("Asante. Tutakupigia simu hivi karibuni. ('%(code)s')") % {"code": problem.name})
def shida(self, message, problem_code, notes):
response = ''
try:
problem = message.reporter.register_event(problem_code, notes=notes)
except ProblemType.DoesNotExist:
response = _("Problem %(code)s not recognized. ") % \
{'code':problem_code}
problem = message.reporter.register_event(SHIDA_CODE)
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SHIDA_CODE) )
message.respond( response + _("Asante. Tutakupigia simu hivi karibuni. ('%(code)s')") % {'code':problem.name} )
def shida(self, message, problem_code):
response = ''
try:
problem = message.reporter.register_event(problem_code)
except ProblemType.DoesNotExist:
response = _("Problem %(code)s not recognized. ") % \
{'code':problem_code}
problem = message.reporter.register_event(SHIDA_CODE)
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SHIDA_CODE) )
message.respond( response + _("Pole for '%(code)s'") % {'code':problem.name} )
def send_summary_activity_to_reporter(router, recipient, context ):
""" SMS document 1: third set
Messages all chv's with a summary of activity from their group
"""
logging.debug("Running brac sms send_summary_activity_to_reporter")
response = []
for chv in context['group_members']:
response.append( _t( _("%(username)s submitted %(count)s forms"),
recipient.language ) %
{ 'username':chv.chw_username, 'count':chv.forms_this_week } )
response = _t(_("Forms submitted: "), recipient.language) + ", ".join(response)
recipient.send_message(router, response)
def send_summary_delinquent_to_super(router, recipient, context):
""" SMS document 2: second set
Send all supervisors a summary of delinquent chv's
"""
logging.debug("Running brac sms send_summary_delinquent_to_super")
usernames = [chv.chw_username for chv in context['delinquent_reporterprofiles']]
if usernames is None or len(usernames)==0:
recipient.send_message(router, _t(_('No delinquents found for delinquent alert'),recipient.language))
response = ", ".join(usernames)
response = response + _t( _(" has not sent any forms for 2 or more days. " + \
"Please follow up to determine the problem."), recipient.language)
recipient.send_message(router, response)
def decorator(self, message, *args):
if not isinstance(message.reporter,Patient) and \
not isinstance(message.reporter,Nurse):
message.respond( _("This number is not registered. ") + \
REGISTER_COMMAND )
return
f(self, message, *args)
def shida_report(router):
# compile report for each site
for site in Site.objects.all():
sawa = PatientState.objects.get(code='sawa')
patient_set = set()
# get all patients who responded shida, 'other', or are in the default state
patients = Patient.objects.filter(site=site).exclude(state=sawa)
for patient in patients:
patient_set.add(patient)
# get all patients in sawa state but from whom we haven't heard in 3 weeks
patients = Patient.objects.filter(site=site).filter(state=sawa, active=False)
for patient in patients:
patient_set.add(patient)
# generate report
report = ''
for patient in patient_set:
report = report + "%s %s %s " % (patient.patient_id, \
patient.connection.identity, patient.state.code)
# send report to all nurses registered for that site
for nurse in Nurse.objects.filter(sites=site):
be = router.get_backend(nurse.connection.backend.slug)
if report:
be.message(nurse.connection.identity, report).send()
else:
be.message(nurse.connection.identity, _("No problem patients")).send()
def shida_report(router, nurse=None):
# list of 'shida' patients for each site, or for a specific nurse if given
sites = nurse.sites.all() if nurse is not None else Site.objects.all()
for site in sites:
shida = PatientState.objects.get(code='shida')
# get all active patients who responded shida or are in the default state
patients = Patient.objects.filter(site=site).filter(state=shida).exclude(active=False).exclude(subscribed=False)
# generate report
report = ''
for patient in patients:
# take the last '1' from Patient ID BA3-2-1
id = patient.patient_id.rsplit('-',1)[-1]
if hasattr(patient,'connection') and patient.connection is not None:
report = report + "%(id)s-%(identity)s " % \
{'id':id,
'identity': patient.connection.identity}
else:
report = report + "%(id)s-None " % {'id':id }
# send report to given nurse, or if nurse not supplied,
# all nurses registered for that site
nurses = [nurse] if nurse is not None else Nurse.objects.filter(sites=site).filter(subscribed=True)
for n in nurses:
be = router.get_backend(n.connection.backend.slug)
if report:
be.message(n.connection.identity, report).send()
else:
be.message(n.connection.identity, _("No problem patients")).send()
def decorator(self, message, *args):
if not isinstance(message.reporter,Patient) and \
not isinstance(message.reporter,Nurse):
message.respond( _("This number is not registered.") + \
REGISTER_COMMAND )
return
f(self, message, *args)
def outcome(self, message, patient_id, outcome_code):
""" Expecting a text from a nurse of the form: <patient-id> <outcome-code> """
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond( _("Patient (%(id)s) not recognized.")%{'id':patient_id} )
return
try:
outcome = patient.register_event(outcome_code, message.reporter)
except OutcomeType.DoesNotExist:
message.respond( _("Outcome (%(code)s) not recognized.")%{'code':outcome_code} )
return
patient.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, outcome_code))
message.respond( _("Patient %(id)s updated to '%(code)s'") % \
{'id':patient_id, 'code':outcome.name} )
def shida_report(router, nurse=None):
# list of 'shida' patients for each site, or for a specific nurse if given
sites = nurse.sites.all() if nurse is not None else Site.objects.all()
for site in sites:
shida = PatientState.objects.get(code='shida')
# get all active patients who responded shida or are in the default state
patients = Patient.objects.filter(site=site).filter(
state=shida).exclude(active=False).exclude(subscribed=False)
# generate report
report = ''
for patient in patients:
# take the last '1' from Patient ID BA3-2-1
id = patient.patient_id.rsplit('-', 1)[-1]
if hasattr(patient,
'connection') and patient.connection is not None:
report = report + "%(id)s-%(identity)s " % \
{'id':id,
'identity': patient.connection.identity}
else:
report = report + "%(id)s-None " % {'id': id}
# send report to given nurse, or if nurse not supplied,
# all nurses registered for that site
nurses = [nurse] if nurse is not None else Nurse.objects.filter(
sites=site).filter(subscribed=True)
for n in nurses:
be = router.get_backend(n.connection.backend.slug)
if report:
be.message(n.connection.identity, report).send()
else:
be.message(n.connection.identity,
_("No problem patients")).send()
def inactive(self, message, text):
""" Set patient to inactive; just for debugging! """
message.reporter.active = False
message.reporter.save()
message.reporter.register_event(INACTIVE_CODE)
if isinstance(message.reporter,Patient):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("%s deactivated" % (message.reporter.alias) )
message.respond( _("Kwaheri") )
def inactive(self, message, text):
""" Set patient to inactive; just for debugging! """
message.reporter.active = False
message.reporter.save()
message.reporter.register_event(INACTIVE_CODE)
if isinstance(message.reporter, Patient):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("%s deactivated" % (message.reporter.alias))
message.respond(_("Kwaheri"))
def is_patient_invalid(self, patient_id, gender=None, phone_number=None):
if len(patient_id) == 0:
return [_("Missing 'patient_id'.") + REGISTER_COMMAND ]
try:
site_code = site_code_from_patient_id(patient_id)
except ValueError:
return [_("Poorly formatted patient_id: %(code)s") % \
{"code" : patient_id}]
try:
Site.objects.get(code=site_code)
except Site.DoesNotExist:
return [_("Unknown sitecode %(code)s") % {"code" : site_code}]
if len(gender) > 0:
if not gender.lower().startswith('m') and not gender.lower().startswith('f'):
return [_("Invalid gender %(gender)s") % {"gender" : gender}]
if len(phone_number) > 0:
if not re.match(r"^\+?\d+$", phone_number):
return [_("Invalid phone number %(num)s") % {"num" : phone_number}]
return False
def is_patient_invalid(self, patient_id, gender=None, phone_number=None):
if len(patient_id) == 0:
return [_("Missing 'patient_id'. ") + REGISTER_COMMAND ]
try:
site_code = site_code_from_patient_id(patient_id)
except ValueError:
return [_("Patient (%(id)s) not recognized") % \
{"id" : patient_id}]
try:
Site.objects.get(code__iexact=site_code)
except Site.DoesNotExist:
response = _("Site %(code)s does not exist") % {"code": site_code }
return [response]
if len(gender) > 0:
if not gender.lower().startswith('m') and not gender.lower().startswith('f'):
return [_("Invalid gender %(gender)s") % {"gender" : gender}]
if len(phone_number) > 0:
if not re.match(r"^\+?\d+$", phone_number):
return [_("Invalid phone number %(num)s") % {"num" : phone_number}]
return False
def from_other_phone_num(self, message, phone_number, text):
if not ((len(phone_number) == 14 and phone_number[:4] == '+254') or \
(len(phone_number) == 11 and phone_number[0] == '0')):
message.respond( "Poorly formatted phone number. Do not use spaces or dashes, e.g. +254712222333." )
return
if len(phone_number) == 14 and phone_number[:4] == '+254':
# remove leading '+254'
phone_number = phone_number[4:]
elif len(phone_number) == 11 and phone_number[0] == '0':
#remove leading '0'
phone_number = phone_number[1:]
try:
conn = PersistantConnection.objects.get(identity__contains=phone_number)
except PersistantConnection.DoesNotExist:
message.respond( _("That phone number is not recognized.") )
return
except PersistantConnection.MultipleObjectsReturned:
message.respond( _("That phone number is associated with more than one account. Please use client ID.") )
return
self.from_other_phone(message, conn.reporter.alias, text)
def outcome(self, message, patient_id, outcome_code, notes):
""" Expecting a text from a nurse of the form: <patient-id> <outcome-code> """
if not isinstance(message.reporter, Nurse):
# we do nurse check manually here, since we want to call 'from_other_phone'
# if sender is not nurse
self.from_other_phone(message, patient_id, outcome_code)
return
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond(_("Patient (%(id)s) not recognized.") % {"id": patient_id})
return
try:
outcome = patient.register_event(outcome_code, message.reporter, notes=notes)
except OutcomeType.DoesNotExist:
message.respond(_("Outcome (%(code)s) not recognized.") % {"code": outcome_code})
return
patient.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, outcome_code))
message.respond(_("Patient %(id)s updated to '%(code)s'") % {"id": patient_id, "code": outcome.name})
def get_or_create_patient(self, patient_id, phone_number=None, \
backend=None, gender=None, date_registered=None):
response = ''
try:
patient = Patient.objects.get(alias=patient_id)
response = _("Patient %(id)s reregistered ") % {"id": patient_id }
p_created = False
except Patient.DoesNotExist:
patient = Patient(alias=patient_id)
response = _("Patient %(id)s registered ") % {"id": patient_id }
p_created = True
site_code = site_code_from_patient_id(patient_id)
patient.site = Site.objects.get( code=site_code )
if gender: patient.gender = gender
patient.state = PatientState.objects.get(code='default')
if date_registered:
patient.date_registered = date_registered
patient.save()
if phone_number is None:
return response
# save connections
conn, c_created = PersistantConnection.objects.get_or_create(\
identity= phone_number, backend=backend)
if conn.reporter is None:
response = response + \
_("with new number %(num)s") % \
{"num": phone_number}
else:
response = response + \
_("with existing number %(num)s") % \
{"num": phone_number }
if conn.reporter.alias != patient.alias:
response = response + _(" (from patient %(old_id)s)") % \
{"old_id": conn.reporter.alias }
conn.reporter = patient
conn.save()
patient.set_preferred_connection( conn )
if p_created:
patient.subscribe()
return (patient, response)
def outcome(self, message, patient_id, outcome_code, notes):
""" Expecting a text from a nurse of the form: <patient-id> <outcome-code> """
if not isinstance(message.reporter,Nurse):
# we do nurse check manually here, since we want to call 'from_other_phone'
# if sender is not nurse
self.from_other_phone(message, patient_id, outcome_code)
return
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond( _("Patient (%(id)s) not recognized.")%{'id':patient_id} )
return
try:
outcome = patient.register_event(outcome_code, message.reporter, notes=notes)
except OutcomeType.DoesNotExist:
message.respond( _("Outcome (%(code)s) not recognized.")%{'code':outcome_code} )
return
patient.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, outcome_code))
message.respond( _("Patient %(id)s updated to '%(code)s'") % \
{'id':patient_id, 'code':outcome.name} )
def report(self, message, report_name):
""" for unit tests ONLY - sends messages to all nurses! """
from weltel.callbacks import shida_report, other_report
report_name = report_name.strip().lower()
if report_name == "shida":
shida_report(self.router, message.reporter)
elif report_name == "other":
other_report(self.router, message.reporter)
else:
logging.info("Nurse %s sent unrecognized command '%s'" % (message.reporter.alias, message.persistent_msg))
message.respond(_("That report is not recognized."))
def report(self, message, report_name):
""" for unit tests ONLY - sends messages to all nurses! """
from weltel.callbacks import shida_report, other_report
report_name = report_name.strip().lower()
if report_name == 'shida':
shida_report(self.router, message.reporter)
elif report_name == 'other':
other_report(self.router, message.reporter)
else:
logging.info("Nurse %s sent unrecognized command '%s'" % \
(message.reporter.alias, message.persistent_msg))
message.respond( _("That report is not recognized.") )
def get_or_create_nurse(self, site_code, phone_number, backend):
try:
site = Site.objects.get(code__iexact=site_code)
except Site.DoesNotExist:
response = _("Site %(code)s does not exist") % {"code": site_code }
return None, response
# for now, set unique id to be phone number
nurse, n_created = Nurse.objects.get_or_create(alias= phone_number)
nurse.sites.add(site)
if n_created:
response = _("Nurse registered") % {"id": nurse.alias }
else:
response = _("Nurse reregistered") % {"id": nurse.alias }
# save connections
conn, c_created = PersistantConnection.objects.get_or_create(identity= phone_number, \
backend= backend)
if conn.reporter is None:
response = response + (_(" with new number %(num)s") % \
{"num": phone_number})
else:
response = response + (_(" with existing number %(num)s") % \
{"num": phone_number})
if nurse.alias != conn.reporter.alias:
response = response + (_(" reregistered from %(old_id)s") % \
{"id": nurse.alias, "old_id": conn.reporter.alias })
conn.reporter = nurse
conn.save()
nurse.subscribe()
return nurse, response
def from_other_phone_num(self, message, phone_number, text):
if not (
(len(phone_number) == 14 and phone_number[:4] == "+254")
or (len(phone_number) == 11 and phone_number[0] == "0")
):
message.respond("Poorly formatted phone number. Do not use spaces or dashes, e.g. +254712222333.")
return
if len(phone_number) == 14 and phone_number[:4] == "+254":
# remove leading '+254'
phone_number = phone_number[4:]
elif len(phone_number) == 11 and phone_number[0] == "0":
# remove leading '0'
phone_number = phone_number[1:]
try:
conn = PersistantConnection.objects.get(identity__contains=phone_number)
except PersistantConnection.DoesNotExist:
message.respond(_("That phone number is not recognized."))
return
except PersistantConnection.MultipleObjectsReturned:
message.respond(_("That phone number is associated with more than one account. Please use client ID."))
return
self.from_other_phone(message, conn.reporter.alias, text)
def alert_delinquent_reporter(router, recipient, context):
""" SMS document 2: first set
Send chv an alert when they haven't submitted anything in 2 days
"""
logging.debug("Running brac sms alert_delinquent_reporter")
last_seen = context['last_seen']
# do not break this string without updating the translation files
response = _t( _("Hi %(username)s, we haven't received any forms " +
"from you for the last %(count)s days. " +
"Please send your forms."),
recipient.language) % \
{ 'username':recipient.chw_username, 'count':last_seen }
recipient.send_message(router, response)
def other_report(router, nurse=None):
# list of 'inactive' and unsubscribed patients for each site
sawa = PatientState.objects.get(code='sawa')
timeout_interval = timedelta(days=1)
timeout = datetime.now() - timeout_interval
sites = nurse.sites.all() if nurse is not None else Site.objects.all()
for site in sites:
report = ''
# get all active patients who unsubscribed today
report_unsubscribed = ''
unsubscribed = Patient.objects.filter(site=site).filter(active=True).filter(subscribed=False)
for p in unsubscribed:
unsubscribe_event = EventLog.objects.filter(patient=p).filter(event__code=UNSUBSCRIBE_CODE).latest()
if not unsubscribe_event:
logging.error("Patient is unsubscribed without unsubscribe event!")
elif unsubscribe_event.date > timeout:
id = p.patient_id.rsplit('-',1)[-1]
if hasattr(p, 'connection') and p.connection is not None:
report_unsubscribed = report_unsubscribed + "%s-%s " % \
(id, p.connection.identity)
else:
report_unsubscribed = report_unsubscribed + "%s-None " % (id)
# get patients who were marked 'inactive' today
report_inactive = ''
inactive = Patient.objects.filter(site=site).filter(active=False)
for p in inactive:
inactivated_event = EventLog.objects.filter(patient=p).filter(event__code=INACTIVE_CODE).latest()
if not inactivated_event:
logging.error("Patient is inactivated without inactivate event!")
elif inactivated_event.date > timeout:
id = p.patient_id.rsplit('-',1)[-1]
if hasattr(p, 'connection') and p.connection is not None:
report_inactive = report_inactive + "%s-%s " % (id, \
p.connection.identity)
else:
report_inactive = report_inactive + "%s-None " % (id)
if report_unsubscribed:
report = report + "Unsubscribed: " + report_unsubscribed
if report_inactive:
report = report + "Inactive: " + report_inactive
# send report to all nurses registered for that site
nurses = [nurse] if nurse is not None else Nurse.objects.filter(sites=site).filter(subscribed=True)
for n in nurses:
be = router.get_backend(n.connection.backend.slug)
if report:
be.message(n.connection.identity, report).send()
else:
be.message(n.connection.identity, _("No patients unsubscribed or were marked inactive today.")).send()
def add_phone(self, message, patient_id):
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond(_("Unknown patient %(id)s.") % {'id':patient_id})
return
patient.related_messages.add(message.persistent_msg)
conn, c_created = PersistantConnection.objects.get_or_create(\
identity=message.persistant_connection.identity, \
backend=message.persistant_connection.backend)
if conn.reporter != patient:
patient.connections.add(conn)
message.respond( "Phone number %(num)s has been registered to patient %(id)s" % \
{"id":patient.patient_id, "num":conn.identity} )
else:
message.respond( "Phone number %(num)s is already registered with patient %(id)s" % \
{"id":patient.patient_id, "num":conn.identity} )
def add_phone(self, message, patient_id):
try:
patient = Patient.objects.get(alias=patient_id)
except Patient.DoesNotExist:
message.respond(_("Unknown patient %(id)s.") % {'id':patient_id})
return
patient.related_messages.add(message.persistent_msg)
conn, c_created = PersistantConnection.objects.get_or_create(\
identity=message.persistant_connection.identity, \
backend=message.persistant_connection.backend)
if conn.reporter != patient:
patient.connections.add(conn)
message.respond( "Phone number %(num)s has been registered to patient %(id)s" % \
{"id":patient.patient_id, "num":conn.identity} )
else:
message.respond( "Phone number %(num)s is already registered with patient %(id)s" % \
{"id":patient.patient_id, "num":conn.identity} )
def get_or_create_patient(self, patient_id, phone_number=None, \
backend=None, gender=None, date_registered=None):
response = ''
try:
patient = Patient.objects.get(alias__iexact=patient_id)
response = _("Patient %(id)s reregistered ") % {"id": patient_id }
if not patient.subscribed:
patient.subscribe()
p_created = False
except Patient.DoesNotExist:
patient = Patient(alias=patient_id)
response = _("Patient %(id)s registered ") % {"id": patient_id }
p_created = True
site_code = site_code_from_patient_id(patient_id)
try:
patient.site = Site.objects.get( code__iexact=site_code )
except Site.DoesNotExist:
response = _("Site %(code)s does not exist") % {"code": site_code }
return (patient, response)
if gender: patient.gender = gender
patient.state = PatientState.objects.get(code='default')
if date_registered:
patient.date_registered = date_registered
patient.save()
if phone_number is None:
return (patient, response)
# save connections
conn, c_created = PersistantConnection.objects.get_or_create(\
identity= phone_number, backend=backend)
if conn.reporter is None:
response = response + \
_("with new number %(num)s") % \
{"num": phone_number}
else:
response = response + \
_("with existing number %(num)s") % \
{"num": phone_number }
if conn.reporter.alias != patient.alias:
response = response + _(" (from patient %(old_id)s)") % \
{"old_id": conn.reporter.alias }
conn.reporter = patient
conn.save()
patient.set_preferred_connection( conn )
# you can only subscribe the patient once you have established
# their preferred connection
patient.subscribe()
return (patient, response)
def send_activity_to_super(router, recipient, context ):
""" SMS document 1: second set
Messages supervisor with activity report for a given chv
"""
logging.debug("Running brac sms send_activity_to_super")
forms_submitted = context['count']
chv = context['chv']
if forms_submitted >= 45:
response = _t( _("%(username)s has submitted %(count)s forms this week. "), recipient.language) + \
_t( _("A work well done!"), recipient.language)
elif forms_submitted >= 26:
response = _t( _("%(username)s has submitted %(count)s forms this week. "), recipient.language) + \
_t( _("Please remind her to submit all the forms every week"), recipient.language)
else:
response = _t( _("%(username)s has submitted %(count)s forms this week. "), recipient.language) + \
_t( _("Please do follow up and ask what seems to be the problem."), recipient.language)
response = response % { 'username':chv.chw_username, 'count':forms_submitted }
recipient.send_message(router, response)
def send_activity_to_reporter(router, recipient, username, forms_submitted ):
""" SMS document 1: first set
Messages chv with a report of her activity in the past week
"""
logging.debug("Running brac sms send_activity_to_reporter")
if forms_submitted >= 45:
greeting = _t( _("Congratulations for the work done %(username)s. "),
recipient.language)
instructions = ""
elif forms_submitted >= 26:
greeting = _t( _("Thank you %(username)s. "), recipient.language)
instructions = _t( _("Please do your best to complete and send all the forms. "),
recipient.language)
else:
greeting = _t( _("Sorry for the trouble %(username)s. "), recipient.language)
instructions = _t( _("Please remember to fill and send the complete reports every week. "),
recipient.language)
info = _t(_("You have submitted %(count)s forms this week. "), recipient.language)
response = greeting + info + instructions + \
_t(_("If the number is incorrect, call Gayo 0786151272."), recipient.language)
response = response % { 'username':username, 'count':forms_submitted }
recipient.send_message(router, response)
def decorator(self, message, *args):
if not isinstance(message.reporter,Nurse):
message.respond( _("This number is not registered to a nurse.") )
return
f(self, message, *args)
#!/usr/bin/env python
# vim: ai ts=4 sts=4 et sw=4 encoding=utf-8
import re
from rapidsms.i18n import ugettext_noop as _
from form.formslogic import FormsLogic
from reporters.models import PersistantConnection
from scheduler.models import set_weekly_event
from weltel.models import Site, Patient, PatientState, Nurse, MALE, FEMALE
from weltel.util import site_code_from_patient_id
REGISTER_COMMAND = _("To register, please refer to your information card.")
NURSE_COMMAND = _("To register, please refer to your information card.")
#TODO - add basic check for when people submit fields in wrong order
#TODO - wrap the validation and actions in pretty wrapper functions
class WeltelFormsLogic(FormsLogic):
''' This class will hold the Weltel-specific forms logic. '''
def validate(self, *args, **kwargs):
message = args[0]
form_entry = args[1]
data = form_entry.to_dict()
if form_entry.form.code.abbreviation == "register":
ret = self.is_patient_invalid(data["patient_id"], \
data["gender"], data["phone_number"])
if not ret:
# all fields were present and correct, so copy them into the
# form_entry, for "actions" to pick up again without re-fetching
form_entry.reg_data = data
def sawa(self, message, sawa, notes=None):
message.reporter.register_event(SAWA_CODE, notes=notes)
message.reporter.related_messages.add(message.persistent_msg)
# Note that all messages are already logged in logger
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SAWA_CODE))
message.respond( _("Asante") )
def unsubscribe(self, message, text):
message.reporter.unsubscribe()
if isinstance(message.reporter,Patient):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("%s unsubscribed" % (message.reporter.alias) )
message.respond( _("Kwaheri") )
def other(self, message):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s sent unrecognized command '%s'" % (message.reporter.alias, message.persistent_msg))
message.respond(_("Please respond 'sawa' or 'shida', followed by any additional comments you have."))
def shida_new(self, message, shida, notes=None):
message.reporter.register_event(SHIDA_CODE, notes=notes)
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SHIDA_CODE) )
message.respond( _("Asante. Tutakupigia simu hivi karibuni.") )
def subscribe(self, message, text):
message.reporter.subscribe()
if isinstance(message.reporter,Patient):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s subscribed" % (message.reporter.alias) )
message.respond( _("Karibu") )
def unsubscribe(self, message, text):
message.reporter.unsubscribe()
if isinstance(message.reporter, Patient):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("%s unsubscribed" % (message.reporter.alias))
message.respond(_("Kwaheri"))
def subscribe(self, message, text):
message.reporter.subscribe()
if isinstance(message.reporter, Patient):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s subscribed" % (message.reporter.alias))
message.respond(_("Karibu"))
def decorator(self, message, *args):
if not isinstance(message.reporter, Nurse):
message.respond(_("This number is not registered to a nurse."))
return
f(self, message, *args)
def sawa(self, message, sawa, notes=None):
message.reporter.register_event(SAWA_CODE, notes=notes)
message.reporter.related_messages.add(message.persistent_msg)
# Note that all messages are already logged in logger
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SAWA_CODE))
message.respond(_("Asante"))
def other(self, message):
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s sent unrecognized command '%s'" % \
(message.reporter.alias, message.persistent_msg))
message.respond( _("Please respond 'sawa' or 'shida', followed by any additional comments you have.") )
def shida_new(self, message, shida, notes=None):
message.reporter.register_event(SHIDA_CODE, notes=notes)
message.reporter.related_messages.add(message.persistent_msg)
logging.info("Patient %s set to '%s'" % (message.reporter.alias, SHIDA_CODE))
message.respond(_("Asante. Tutakupigia simu hivi karibuni."))
