def patient_onetime_message(request, patient_id):
"""Send a onetime message to a patient.
Default to getting it from their feeds but allow editing that."""
patient = get_object_or_404(patients.Patient, pk=patient_id)
if request.method == 'POST':
form = PatientOnetimeMessageForm(request.POST)
if form.is_valid():
message = form.cleaned_data['message']
connection = patient.contact.default_connection
msg = OutgoingMessage(connection, message)
router = Router()
success = True
try:
router.outgoing(msg)
except Exception, e:
logger.exception(e)
success = False
if success:
messages.success(
request,
"Message sent to patient %s" % patient.subject_number)
else:
messages.error(
request,
"An error occurred while trying to send the message to patient %s"
% patient.subject_number)
return redirect('patient-list')
def reimburse():
'''
Start reimbursement process, entailing interaction with special numbers
'''
counter = 0
network_name_map = dict([(v, k) for k, v in NAME_NETWORK_MAP.items()])
reimbursements = ReimbursementRecord.objects.exclude(
status__in=(ReimbursementRecord.COMPLETED, ReimbursementRecord.ERROR)
)
#import pdb;pdb.set_trace()
for network, _ in Subscriber.NETWORKS:
print 'network: %s'%network
if reimbursements.filter(
status__in=(
ReimbursementRecord.IN_PROGRESS, ReimbursementRecord.QUEUED),
subscriber__network=network):
continue
else:
#there is no reimbursement in progress for "network"
subscribers = Subscriber.objects.filter(balance__gt=0, network=network)
min_time = settings.REIMBURSEMENT_MIN_TIME
qualified = qualify(subscribers, min_time)
if qualified:
subscriber = qualified[0]
else:
continue
network_name = network_name_map.get(network)
_amount = max(subscriber.balance, settings.MINIMUM_TRANSFERS.get(network_name))
backend_name = subscriber.get_backend()
backend, _ = Backend.objects.get_or_create(name=backend_name)
text = subscriber.first_message % {
'number': '0%s'%subscriber.number[-10:],
'amount': _amount,
'pin': settings.NETWORK_PINS.get(network_name)
}
logging.info('message to send is %s'%text)
to_number = REIMBURSEMENT_NUMBERS.get(network_name)
if len(to_number) < 11:#If it is a short-code, prefix with 's'
to_number = 's%s'%to_number
connection, _ = Connection.objects.get_or_create(
backend=backend, identity=to_number)
msg = OutgoingMessage(connection=connection, template=text)
try:
msg.send()
except:
router = Router()
#router.start()
router.outgoing(msg)
ReimbursementRecord.objects.create(
subscriber=subscriber,
amount=_amount,
status=ReimbursementRecord.IN_PROGRESS)
counter += 1
return counter
def session_end(sender, **kwargs):
session = kwargs['session']
canceled = kwargs['canceled']
message = kwargs['message']
# for convenience
PatientSurvey = aremind.apps.adherence.models.PatientSurvey
# find the patient
connection = session.connection
try:
patient = Patient.objects.get(contact=connection.contact)
except Patient.DoesNotExist:
# No patient, this session might not be relevant to this app
return
survey = PatientSurvey.find_active(patient, QUERY_TYPE_SMS)
if not survey:
return
if canceled:
survey.completed(PatientSurvey.STATUS_NOT_COMPLETED)
return
tree = session.tree
entries = session.entries
if entries.count() < 1:
survey.completed(PatientSurvey.STATUS_NOT_COMPLETED)
return
entry = entries.all()[0]
# Pick the relevant part of the answer
text = re.match(ANSWER_RE, entry.text).group(1)
num_pills = int(text)
if not survey.is_test:
aremind.apps.adherence.models.PillsMissed(
patient=patient, num_missed=num_pills,
source=QUERY_TYPE_SMS).save()
survey.completed(PatientSurvey.STATUS_COMPLETE)
# After completing survey, tell patient what their current adherence is
connection = patient.contact.default_connection
adherence = patient.adherence() # integer percentage
response_text = _(
"Thank you. Your adherence is %(adherence)s%%, as measured by the black study pillbox."
)
kwargs = dict(adherence=adherence)
if message:
message.respond(response_text, **kwargs)
else:
msg = OutgoingMessage(connection, response_text, **kwargs)
router = Router()
router.outgoing(msg)
def session_end(sender, **kwargs):
session = kwargs["session"]
canceled = kwargs["canceled"]
message = kwargs["message"]
# for convenience
PatientSurvey = aremind.apps.adherence.models.PatientSurvey
# find the patient
connection = session.connection
try:
patient = Patient.objects.get(contact=connection.contact)
except Patient.DoesNotExist:
# No patient, this session might not be relevant to this app
return
survey = PatientSurvey.find_active(patient, QUERY_TYPE_SMS)
if not survey:
return
if canceled:
survey.completed(PatientSurvey.STATUS_NOT_COMPLETED)
return
tree = session.tree
entries = session.entries
if entries.count() < 1:
survey.completed(PatientSurvey.STATUS_NOT_COMPLETED)
return
entry = entries.all()[0]
# Pick the relevant part of the answer
text = re.match(ANSWER_RE, entry.text).group(1)
num_pills = int(text)
if not survey.is_test:
aremind.apps.adherence.models.PillsMissed(patient=patient, num_missed=num_pills, source=QUERY_TYPE_SMS).save()
survey.completed(PatientSurvey.STATUS_COMPLETE)
# After completing survey, tell patient what their current adherence is
connection = patient.contact.default_connection
adherence = patient.adherence() # integer percentage
response_text = _("Thank you. Your adherence is %(adherence)s%%, as measured by the black study pillbox.")
kwargs = dict(adherence=adherence)
if message:
message.respond(response_text, **kwargs)
else:
msg = OutgoingMessage(connection, response_text, **kwargs)
router = Router()
router.outgoing(msg)
def handle(self, *args, **options):
if len(args) != 1: raise CommandError('Please specify %s.' % self.label)
message = args[0]
all_connections = Connection.objects.all()
success = []
failed = []
router = Router()
for conn in all_connections:
try:
router.outgoing(OutgoingMessage(conn, message))
success.append(conn)
except Exception, e:
print "failed to send to %s because %s" % (conn, e)
failed.append(conn)
def send_activity_digest_sms(sender, instance, created, **kwargs):
"""
Uses threadless_router to send the activity digest via SMS to
all available contacts associated with the user. This will happen only
once when the NotificationVisibility object is created.
The default SMS handling provided by rapidsms-alerts is not compatible
with threadless router.
"""
alert_types = [PBFDigestNotification.alert_type, FadamaDigestNotification.alert_type]
sent = False
if created and instance.notif.alert_type in alert_types:
notification = instance.notif
contacts = instance.user.contact_set.all()
for contact in contacts:
connection = contact.default_connection
if connection:
backend = connection.backend
message = OutgoingMessage(connection, notification.text)
router = ThreadlessRouter()
response = router.outgoing(message)
sent = True
if sent:
# Don't show this notification on the dashboard as we've already sent
# it as a text message.
instance.delete()
def patient_onetime_message(request, patient_id):
"""Send a onetime message to a patient.
Default to getting it from their feeds but allow editing that."""
patient = get_object_or_404(patients.Patient, pk=patient_id)
if request.method == 'POST':
form = PatientOnetimeMessageForm(request.POST)
if form.is_valid():
message = form.cleaned_data['message']
connection = patient.contact.default_connection
msg = OutgoingMessage(connection, message)
router = Router()
success = True
try:
router.outgoing(msg)
except Exception, e:
logger.exception(e)
success = False
if success:
messages.success(request, "Message sent to patient %s" % patient.subject_number)
else:
messages.error(request, "An error occurred while trying to send the message to patient %s" % patient.subject_number)
return redirect('patient-list')
def reimbursement_detail(request, number):
reimbursements = ReimbursementLog.objects.filter(phone=number).order_by('-reimbursed_on')
num_messages = Message.objects.filter(connection__identity=number, direction='I').count()
owed = settings.REIMBURSEMENT_RATES[network_for_number(number)] * num_messages - sum([r.amount for r in reimbursements])
from django import forms
from django.contrib.admin.widgets import AdminDateWidget
class ReimbursementForm(forms.Form):
amount = forms.IntegerField()
when = forms.DateField(widget=AdminDateWidget, required=False)
def clean_amount(self):
data = self.cleaned_data['amount']
if data <= 0:
raise forms.ValidationError('can\'t be 0 or negative')
return data
if request.method == 'POST':
form = ReimbursementForm(request.POST)
if form.is_valid():
entry_date = form.cleaned_data['when']
entry = ReimbursementLog(
phone=number,
amount=form.cleaned_data['amount'],
reimbursed_on=datetime.now() if (not entry_date or entry_date == date.today()) else entry_date,
)
entry.save()
network_name = network_for_number(number)
network = NAME_NETWORK_MAP.get(network_name)
try:
subscriber = Subscriber.objects.get(
number=number[-13:], network=network)
except Subscriber.DoesNotExist:
pass
else:
balance = subscriber.balance - form.cleaned_data['amount']
subscriber.balance = max(balance, 0)
subscriber.save()
#import pdb;pdb.set_trace()
backend_name = get_backend_name(network_name)
backend, _ = Backend.objects.get_or_create(name=backend_name)
try:
conn = Connection.objects.get(identity=number, backend=backend)
except Exception:
#log somewhere?
pass
else:
notice = OutgoingMessage(connection=conn, template=settings.REIMBURSEMENT_NOTICE)
router = Router()
router.outgoing(notice)
return HttpResponseRedirect('/dashboard/reimbursement/')
else:
form = ReimbursementForm()
return render(request, 'dashboard/reimbursement_detail.html', {
'number': disp_number(number),
'network': network_for_number(number),
'owed': owed,
'over': owed < 0,
'over_amt': -owed,
'history': reimbursements,
'form': form,
})
def message_report_beneficiary(report, message_text):
"Send a message to a user based on a report."
template = u'{0} {1}'.format(communicator_prefix(), message_text)
message = OutgoingMessage(connection=report.reporter, template=template)
router = Router()
router.outgoing(message)
