def data(req):
template_name = "iavi/data.html"
user = req.user
try:
profile = user.get_profile()
locations = profile.locations.all()
except IaviProfile.DoesNotExist:
# if they don't have a profile they aren't associated with
# any locations and therefore can't view anything. Only
# exceptions are the superusers
if user.is_superuser:
# todo: allow access to everything
locations = Location.objects.all()
else:
return render_to_response(req, "iavi/no_profile.html", {})
seven_days = timedelta(days=7)
#thirty_days = timedelta(days=30)
tomorrow = datetime.today() + timedelta(days=1)
kenya_reports = KenyaReport.objects.filter(
started__gte=tomorrow - seven_days).filter(
reporter__location__in=locations).order_by("-started")
uganda_reports = UgandaReport.objects.filter(
started__gte=tomorrow - seven_days).filter(
reporter__location__in=locations).order_by("-started")
return render_to_response(req, template_name, {
"kenya_reports": kenya_reports,
"uganda_reports": uganda_reports
})
def data(req):
template_name = "iavi/data.html"
user = req.user
try:
profile = user.get_profile()
locations = profile.locations.all()
except IaviProfile.DoesNotExist:
# if they don't have a profile they aren't associated with
# any locations and therefore can't view anything. Only
# exceptions are the superusers
if user.is_superuser:
# todo: allow access to everything
locations = Location.objects.all()
else:
return render_to_response(req, "iavi/no_profile.html", {})
seven_days = timedelta(days=7)
# thirty_days = timedelta(days=30)
tomorrow = datetime.today() + timedelta(days=1)
kenya_reports = (
KenyaReport.objects.filter(started__gte=tomorrow - seven_days)
.filter(reporter__location__in=locations)
.order_by("-started")
)
uganda_reports = (
UgandaReport.objects.filter(started__gte=tomorrow - seven_days)
.filter(reporter__location__in=locations)
.order_by("-started")
)
return render_to_response(req, template_name, {"kenya_reports": kenya_reports, "uganda_reports": uganda_reports})
def data(req, id = None):
allTrees = Tree.objects.all()
# ok, the plan is to generate a table of responses per state, but this is tricky with loops.
# the first thing we'll do is get all the possible states you can reach from the tree
# then we'll tabulate the results of each state's first value
# then we'll look at paths, by using the concatenated list of states taken for that path as a key
if len(allTrees) != 0:
t = get_tree(id)
all_states = t.get_all_states()
loops = t.has_loops()
if not loops:
# this is the easy case. just create one column per state and then display the results
sessions = Session.objects.all().filter(tree=t)
return render_to_response(req, "tree/data.html",
{ "trees": allTrees, "t": t, "states" : all_states, "sessions" : sessions, "loops" : loops}
)
else:
# here what we want is a table where the columns are every unique path through the
# tree, and the rows are the sessions, with the paths filled in.
# Since there are loops we have to generate the list of unique paths from
# the session data.
# So we get every session, and for every entry in that session we get the path.
# If we haven't seen the path we add it to the master list.
# Then we walk back through the master list, and walk through each session to
# see if it has an entry matching that path, and if so set the answer.
sessions = Session.objects.all().filter(tree=t)
paths = {}
# i think paths will be a dictionary of paths to dictionaries of sessions to answers
# e.g. { <path> : { <session> : <answer>}
# which will allow us to iterate through paths and say:
# if paths[path].has_key(session):
# this_cell = paths[path][session]
for session in sessions:
entries = session.entry_set.all().order_by('sequence_id')
path = ''
for entry in entries:
path = path + str(entry.transition.current_state.id) + '/'
entry.path = path
if paths.has_key(path):
paths[path][session] = entry.transition.answer
else:
paths[path] = { session : entry.transition.answer }
return render_to_response(req, "tree/data.html",
{ "trees": allTrees, "t": t, "paths" : paths, "sessions" : sessions, "loops" : loops }
)
# now we need to map all states to answers
states_w_answers = {}
for state in all_states:
states_w_answers[state] = map((lambda x: x.answer), state.transition_set.all())
# now we need to get all the entries
all_entries = Entry.objects.all().filter(session__tree = t)
if loops:
# stupid error fix to prevent trees with loops from exploding. This should be done better
t = Tree()
t.trigger = "Sorry, can't display this tree because it has loops. We're working on it."
return render_to_response(req, "tree/index.html",
{ "trees": allTrees, "t": t })
else:
return render_to_response("tree/index.html",
context_instance=RequestContext(req))
def select( request,
redirect_field_name = REDIRECT_FIELD_NAME,
domain_select_template = 'domain/select.html' ):
domains_for_user = Domain.active_for_user(request.user)
if len(domains_for_user) == 0:
vals = dict( error_msg = "You are not a member of any existing domains - please contact your system administrator",
show_homepage_link = False )
return render_to_response(request, 'error.html', vals)
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == 'POST': # If the form has been submitted...
form = DomainSelectionForm(domain_list=domains_for_user,
data=request.POST) # A form bound to the POST data
if form.is_valid():
# We've just checked the submitted data against a freshly-retrieved set of domains
# associated with the user. It's safe to set the domain in the sesssion (and we'll
# check again on views validated with the domain-checking decorator)
form.save(request) # Needs request because it saves domain in session
# Weak attempt to give user a good UX - make sure redirect_to isn't garbage.
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = reverse('homepage')
return HttpResponseRedirect(redirect_to) # Redirect after POST
else:
# An unbound form
form = DomainSelectionForm( domain_list=domains_for_user )
vals = dict( next = redirect_to,
form = form )
return render_to_response(request, domain_select_template, vals)
def users(req):
template_name = "iavi/users.html"
current_user = req.user
try:
profile = current_user.get_profile()
locations = profile.locations.all()
except IaviProfile.DoesNotExist:
# if they don't have a profile they aren't associated with
# any locations and therefore can't view anything. Only
# exceptions are the superusers
if current_user.is_superuser:
# todo: allow access to everything
locations = Location.objects.all()
else:
return render_to_response(req, "iavi/no_profile.html", {})
all_users = User.objects.all()
for user in all_users:
try:
profile = user.get_profile()
# set some fields in the user object so we can access them in the template
location_strings = [
str(location) for location in profile.locations.all()
]
user.locations = ", ".join(location_strings)
except IaviProfile.DoesNotExist:
user.locations = ""
if user.is_superuser:
user.permission_string = "Administrator"
else:
user.permission_string = ", ".join(
[str(group) for group in user.groups.all()])
return render_to_response(req, template_name, {"all_users": all_users})
def users(req):
template_name = "iavi/users.html"
current_user = req.user
try:
profile = current_user.get_profile()
locations = profile.locations.all()
except IaviProfile.DoesNotExist:
# if they don't have a profile they aren't associated with
# any locations and therefore can't view anything. Only
# exceptions are the superusers
if current_user.is_superuser:
# todo: allow access to everything
locations = Location.objects.all()
else:
return render_to_response(req, "iavi/no_profile.html", {})
all_users = User.objects.all()
for user in all_users:
try:
profile = user.get_profile()
# set some fields in the user object so we can access them in the template
location_strings = [str(location) for location in profile.locations.all()]
user.locations = ", ".join(location_strings)
except IaviProfile.DoesNotExist:
user.locations = ""
if user.is_superuser:
user.permission_string = "Administrator"
else:
user.permission_string = ", ".join([str(group) for group in user.groups.all()])
return render_to_response(req, template_name, {"all_users": all_users})
def index(req):
allTrees = Tree.objects.all()
if len(allTrees) != 0:
t = allTrees[len(allTrees) - 1]
return render_to_response(req, "tree/index.html",
{ "trees": allTrees, "t": t })
else:
return render_to_response(req, "tree/index.html", {})
def report_view(req):
cls = ReportMalnutrition
report_title = cls._meta.verbose_name
rows = []
reports = cls.objects.all()
i = 0
for report in reports:
i += 1
row = {}
row["cells"] = []
row["cells"].append({"value": report.case})
row["cells"].append({"value": report.reporter})
row["cells"].append({"value": \
report.entered_at.strftime("%d/%m/%Y")})
row["cells"].append({"value": report.muac, "num": True})
row["cells"].append({"value": report.height, "num": True})
row["cells"].append({"value": report.weight, "num": True})
row["cells"].append({"value": report.status})
if i == 100:
row['complete'] = True
rows.append(row)
break
rows.append(row)
columns, sub_columns = cls.table_columns()
aocolumns_js = "{ \"sType\": \"html\" },"
for col in columns[1:] + (sub_columns if sub_columns != None else []):
if not 'colspan' in col:
aocolumns_js += "{ \"asSorting\": [ \"desc\", \"asc\" ], " \
"\"bSearchable\": false },"
aocolumns_js = aocolumns_js[:-1]
aggregate = False
print columns
print sub_columns
print len(rows)
context_dict = {'get_vars': req.META['QUERY_STRING'],
'columns': columns, 'sub_columns': sub_columns,
'rows': rows, 'report_title': report_title,
'aggregate': aggregate, 'aocolumns_js': aocolumns_js}
if req.method == 'GET' and 'excel' in req.GET:
'''response = HttpResponse(mimetype="application/vnd.ms-excel")
filename = "%s %s.xls" % \
(report_title, datetime.now().strftime("%d%m%Y"))
response['Content-Disposition'] = "attachment; " \
"filename=\"%s\"" % filename
from findug.utils import create_excel
response.write(create_excel(context_dict))
return response'''
return render_to_response(req, 'childcount/report.html', context_dict)
else:
return render_to_response(req, 'childcount/report.html', context_dict)
def config_submit(req):
c = MTurkConfig.objects.filter(current=True)
if c:
template_path = "xtrans/config_submit.html"
f = ConfigForm(instance=c)
return render_to_response(req, template_path, {'form':f})
else:
template_path = "xtrans/config_blank.html"
return render_to_response(req,template_path,{})
def index(req):
allTrees = Tree.objects.all()
if len(allTrees) != 0:
t = allTrees[len(allTrees) - 1]
return render_to_response(req, "tree/index.html", {
"trees": allTrees,
"t": t
})
else:
return render_to_response(req, "tree/index.html", {})
def custom_report(request, domain_id, report_name):
context = {}
context["report_name"] = report_name
report_method = util.get_report_method(request.user.selected_domain, report_name)
if not report_method:
return render_to_response(request,
"custom/report_not_found.html",
context)
context["report_display"] = report_method.__doc__
context["report_body"] = report_method(request)
return render_to_response(request, "custom/base.html", context)
def reports(request, template_name="list.html"):
# not sure where this view will live in the UI yet
context = {}
extuser = request.extuser
context["domain"] = extuser.domain
context["case_reports"] = Case.objects.filter(domain=extuser.domain)
context["sql_reports"] = SqlReport.objects.filter(domain=extuser.domain, is_active=True)
context["custom_reports"] = util.get_custom_reports(extuser.domain)
if not context["custom_reports"] and not context["sql_reports"] and not context["case_reports"]:
return render_to_response(request, "domain_not_found.html", context)
return render_to_response(request, template_name, context)
def reports(request, template_name="list.html"):
# not sure where this view will live in the UI yet
context = {}
context['case_reports'] = Case.objects.filter(domain=request.user.selected_domain)
context['sql_reports'] = SqlReport.objects.filter(domain=request.user.selected_domain, is_active=True)
context['custom_reports'] = util.get_custom_reports(request.user.selected_domain)
if not context['custom_reports'] and not context['sql_reports']\
and not context['case_reports']:
return render_to_response(request,
"domain_not_found.html",
context)
return render_to_response(request, template_name, context)
def all_builds(request, template_name="buildmanager/all_builds.html"):
context = {}
try:
extuser = ExtUser.objects.all().get(id=request.user.id)
context["domain"] = extuser.domain
projects = Project.objects.filter(domain=extuser.domain)
builds = _get_build_dictionary(projects)
context['all_builds'] = builds
except ExtUser.DoesNotExist:
template_name="hq/no_permission.html"
return render_to_response(request, template_name, context)
return render_to_response(request, template_name, context)
def post(req, template_name):
xform_body = req.POST["xform"]
try:
result, errors, has_error = readable_form(xform_body)
return render_to_response(req, template_name, {"success": True,
"message": "Your form was successfully validated!",
"xform": xform_body,
"readable_form": result
})
except Exception, e:
return render_to_response(req, template_name, {"success": False,
"message": "Failure to generate readable xform! %s" % e,
"xform": xform_body
})
def post(req, template_name):
xform_body = req.POST["xform"]
hq_validation = True if "hq-validate" in req.POST else False
try:
xformvalidator.validate_xml(xform_body, do_hq_validation=hq_validation)
return render_to_response(
req,
template_name,
{"success": True, "message": "Your form was successfully validated!", "xform": xform_body},
)
except Exception, e:
return render_to_response(
req, template_name, {"success": False, "message": "Validation Fail! %s" % e, "xform": xform_body}
)
def compliance(req):
template_name = "iavi/compliance.html"
user = req.user
try:
profile = user.get_profile()
locations = profile.locations.all()
except IaviProfile.DoesNotExist:
# if they don't have a profile they aren't associated with
# any locations and therefore can't view anything. Only
# exceptions are the superusers
if user.is_superuser:
locations = Location.objects.all()
else:
return render_to_response(req, "iavi/no_profile.html", {})
reporters = IaviReporter.objects.filter(
location__in=locations).order_by('alias')
seven_days = timedelta(days=7)
thirty_days = timedelta(days=30)
today = datetime.today()
tomorrow = today + timedelta(days=1)
for reporter in reporters:
all_reports = Report.objects.filter(reporter=reporter)
last_7 = all_reports.filter(started__gte=today - seven_days)
last_30 = all_reports.filter(started__gte=today - thirty_days)
reporter.all_reports = len(all_reports)
reporter.all_compliant = len(all_reports.filter(status="F"))
if reporter.all_reports != 0:
reporter.all_ratio = float(reporter.all_compliant) / float(
reporter.all_reports)
reporter.all_flag = _get_flag(reporter.all_ratio)
reporter.past_7_reports = len(last_7)
reporter.past_7_compliant = len(last_7.filter(status="F"))
if reporter.past_7_reports != 0:
reporter.past_7_ratio = float(reporter.past_7_compliant) / float(
reporter.past_7_reports)
reporter.past_7_flag = _get_flag(reporter.past_7_ratio)
reporter.past_30_reports = len(last_30)
reporter.past_30_compliant = len(last_30.filter(status="F"))
if reporter.past_30_reports != 0:
reporter.past_30_ratio = float(reporter.past_30_compliant) / float(
reporter.past_30_reports)
reporter.past_30_flag = _get_flag(reporter.past_30_ratio)
return render_to_response(req, template_name, {"reporters": reporters})
def index(request, template="weltel/index.html"):
context = {}
sites = Site.objects.all().order_by('name')
start_of_week = datetime.now()
# set to monday 00:00
start_of_week = start_of_week - timedelta(days=start_of_week.weekday(),
hours=start_of_week.hour,
minutes=start_of_week.minute)
for site in sites:
patients = Patient.objects.filter(site=site)
site.patient_count = patients.count()
site.nurse_count = Nurse.objects.filter(sites=site).count()
sawa_patients = patients.filter(state__code=SAWA_CODE)
shida_patients = patients.filter(state__code=SHIDA_CODE)
site.sawa_count = sawa_patients.count()
site.shida_count = shida_patients.count()
sawa_patients_this_week = sawa_patients.filter(active=True).filter(
subscribed=True)
sawa_patients_this_week = sawa_patients_this_week.filter(
eventlog__date__gte=start_of_week)
site.sawa_count_this_week = sawa_patients_this_week.distinct().count()
shida_patients_this_week = shida_patients.filter(active=True).filter(
subscribed=True)
shida_patients_this_week = shida_patients_this_week.filter(
eventlog__date__gte=start_of_week)
site.shida_count_this_week = shida_patients_this_week.distinct().count(
)
context['sites'] = paginated(request, sites)
#messages = EventLog.objects.select_related().order_by('-received')
#context.update( format_events_in_context(request, context, messages) )
return render_to_response(request, template, context)
def user_edit(req, id):
user_to_edit = User.objects.get(id=id)
try:
profile = user_to_edit.get_profile()
except IaviProfile.DoesNotExist:
profile = None
if req.method == 'POST':
user_form = UserForm(req.POST, instance=user_to_edit)
profile_form = IaviProfileForm(req.POST, instance=profile)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
if user.is_superuser:
# make sure any super user is also staff so they
# can easily change passwords
user.is_staff = True
user.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
profile_form.save_m2m()
return HttpResponseRedirect('/iavi/users')
else:
user_form = UserForm(instance=user_to_edit)
profile_form = IaviProfileForm(instance=profile)
template_name = "iavi/user_edit.html"
return render_to_response(
req, template_name, {
"current_user": user_to_edit,
"user_form": user_form,
"profile_form": profile_form
})
def show_build(request, build_id, template_name="buildmanager/show_build.html"):
context = {}
try:
context["build"] = ProjectBuild.objects.get(id=build_id)
except:
raise Http404
return render_to_response(request, template_name, context)
def schools(req, template_name="schools/school_list.html"):
regions = Location.objects.filter(type__name="Region")
districts = None
region = None
district = None
filter_params = get_location_filter_params(req)
print filter_params
schools = School.objects.filter(**filter_params)
if "region" in req.GET:
region = Location.objects.get(id=req.GET["region"])
elif "district" in req.GET:
district = Location.objects.get(id=req.GET["district"])
region = district.parent
if region:
districts = region.children.filter(type__name="District")
else:
schools = School.objects.all()
return render_to_response(
req, template_name, {
"regions": regions,
"districts": districts,
"selected_region": region,
"selected_district": district,
"schools": schools
})
def index(req):
facilities = Facility.objects.all().order_by('name')
if req.method == 'POST': # If the form has been submitted...
form = FilterChoiceForm(req.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# saving the form data is not cleaned
#form.save()
start_date = form.cleaned_data["start_date"]
end_date = form.cleaned_data['end_date']
status = form.cleaned_data['resource_status']
resources = Resource.objects.filter(facility__in = facilities)
resources = resources.filter(status__in = status)
facilities = []
for resource in resources:
facilities.append(resource.facility)
print 'START: %s -------------- END: %s ---------- STATUS: %s' % (start_date, end_date, status)
#return HttpResponse('You just submit a form..Horray!')
else:
form = FilterChoiceForm() # An unbound form
return render_to_response(req,
'mapindex.html',
{
'facilities': facilities,
'form': form,
},
)
def summary_trend(request, template_name="graphing/summary_trend.html"):
"""This is just a really really basic trend of total counts for a given set
of forms under this domain/organization"""
context = {}
formname = ''
formdef_id = -1
for item in request.GET.items():
if item[0] == 'formdef_id':
formdef_id=item[1]
if formdef_id == -1:
context['chart_title'] = 'All Data'
context['dataset'] = {}
defs = FormDefModel.objects.all().filter(domain=request.user.selected_domain)
for fdef in defs:
d = dbhelper.DbHelper(fdef.element.table_name, fdef.form_display_name)
context['dataset'][fdef.form_display_name.__str__()] = d.get_counts_dataset(None,None)
else:
fdef = FormDefModel.objects.all().filter(id=formdef_id)
context['chart_title'] = fdef[0].form_display_name
d = dbhelper.DbHelper(fdef[0].element.table_name,fdef[0].form_display_name)
context['dataset'] = d.get_integer_series_dataset()
context ['maxdate'] = 0;
context ['mindate'] = 0;
return render_to_response(request, template_name, context)
def export(req, id = None):
t = get_tree(id)
all_states = t.get_all_states()
loops = t.has_loops()
if not loops:
output = StringIO()
w = csv.writer(output)
headings = ["Person", "Date"]
headings.extend([state.question for state in all_states])
w.writerow(headings)
sessions = Session.objects.all().filter(tree=t)
for session in sessions:
values = [str(session.person), session.start_date]
transitions = map((lambda x: x.transition), session.entry_set.all())
states_w_transitions = {}
for transition in transitions:
states_w_transitions[transition.current_state] = transition
for state in all_states:
if states_w_transitions.has_key(state):
values.append(states_w_transitions[state].answer)
else:
values.append("")
w.writerow(values)
# rewind the virtual file
output.seek(0)
response = HttpResponse(output.read(),
mimetype='application/ms-excel')
response["content-disposition"] = "attachment; filename=%s.csv" % t.trigger
return response
else:
return render_to_response(req, "tree/index.html",{})
def view_graph(request, graph_id, template_name="graphing/view_graph.html"):
context = {}
graph = RawGraph.objects.all().get(id=graph_id)
#get the root group
# inject some stuff into the rawgraph. we can also do more
# here but for now we'll just work with the domain and set
# some dates. these can be templated down to the sql
graph.domain = request.user.selected_domain.name
startdate, enddate = utils.get_dates(request, graph.default_interval)
graph.startdate = startdate.strftime("%Y-%m-%d")
graph.enddate = (enddate + timedelta(days=1)).strftime("%Y-%m-%d")
context['chart_title'] = graph.title
context['chart_data'] = graph.get_flot_data()
context['thegraph'] = graph
rootgroup = utils.get_chart_group(request.user)
graphtree = get_graphgroup_children(rootgroup)
context['graphtree'] = graphtree
context['view_name'] = 'graphing.views.view_graph'
context['width'] = graph.width
context['height'] = graph.height
context['empty_dict'] = {}
context['datatable'] = graph.convert_data_to_table(context['chart_data'])
for item in request.GET.items():
if item[0] == 'bare':
template_name = 'graphing/view_graph_bare.html'
elif item[0] == 'data':
template_name='graphing/view_graph_data.html'
elif item[0] == 'csv':
return _get_chart_csv(graph)
return render_to_response(request, template_name, context)
def reporter_view(req, reporter_id):
''' Displays a summary of his activities and history '''
reporter = Reporter.objects.get(id=reporter_id)
return render_to_response(req, 'findug/reporter.html',
{"reporter": reporter})
def inspector(request, table_name, template_name="graphing/table_inspector.html"):
context = {}
context['table_name'] = table_name
str_column = None
str_column_value = None
datetime_column = None
data_column = None
display_mode = None
for item in request.GET.items():
if item[0] == 'str_column':
str_column = item[1]
if item[0] == 'str_column_value':
str_column_value = item[1]
if item[0] == 'datetime_column':
datetime_column = item[1]
if item[0] == 'data_column':
data_column = item[1]
if item[0] == 'display_mode':
display_mode = item[1]
context['str_column'] = str_column
context['str_column_value'] = str_column_value
context['datetime_column'] = datetime_column
context['data_column'] = data_column
context['display_mode'] = display_mode
return render_to_response(request, template_name, context)
def basic_ui(req, number, skip_post=False, form_class=MessageForm):
form_instance = form_class()
template_name = "http/index.html"
if req.method == 'POST' and req.POST.has_key("phone_number"):
number = req.POST["phone_number"]
msgs = Message.objects.all().filter(phone_number=number)
if not skip_post and req.method == 'POST':
form_instance = form_class(req.POST)
if form_instance.is_valid():
msg = form_instance.save(commit=False)
msg.phone_number = number
msg.date = datetime.datetime.now()
msg.save()
url = "http://localhost:8080/%s/%s" % (msg.phone_number,
urllib2.quote(msg.body))
urllib2.urlopen(url)
#return render_to_response('shared/thanks.html')
return basic_ui(req, msg.phone_number, True)
else:
print "something bad happened"
return render_to_response(req, template_name, {
"form": form_instance,
"msgs": msgs,
"number": number
})
def index(req):
template_name="logger/index_flat.html"
columns = (("date", "Date"),
("connection__identity", "From/To"),
("connection__backend", "Backend"),
("is_incoming", "Direction"),
("text", "Message"))
sort_column, sort_descending = _get_sort_info(req, default_sort_column="date",
default_sort_descending=True)
sort_desc_string = "-" if sort_descending else ""
search_string = req.REQUEST.get("q", "")
query = Message.objects.select_related("connection", "connection__backend"
).order_by("%s%s" % (sort_desc_string, sort_column))
if search_string == "":
query = query.all()
else:
query = query.filter(
Q(text__icontains=search_string) |
Q(connection__identity__icontains=search_string))
messages = paginated(req, query)
return render_to_response(req, template_name, {"columns": columns,
"messages": messages,
"sort_column": sort_column,
"sort_descending": sort_descending,
"search_string": search_string})
def org_sms_report(request, template_name="hq/org_single_report.html"):
context = {}
# the decorator and middleware ensure this will be set.
extuser = request.extuser
startdate, enddate = utils.get_dates(request)
context['startdate'] = startdate
context['enddate'] = enddate
context['extuser'] = extuser
context['domain'] = extuser.domain
context['daterange_header'] = repinspector.get_daterange_header(startdate, enddate)
context['view_name'] = 'hq.views.org_sms_report'
# commented out because these reports aren't actually different reports
# report = ReportSchedule.objects.get(id=id)
# context["report"] = report
# get the domain from the user, the root organization from the domain,
# and then the report from the root organization
#reporter.
root_orgs = Organization.objects.filter(parent=None, domain=extuser.domain)
# note: this pretty sneakily decides for you that you only care
# about one root organization per domain. should we lift this
# restriction? otherwise this may hide data from you
root_org = root_orgs[0]
# this call makes the meat of the report.
#data = repinspector.get_data_below(root_org, startdate, enddate, 0)
#data = custom._get_flat_data_for_domain(extuser.domain, startdate, enddate + timedelta(days=1))
data = custom._get_flat_data_for_domain(extuser.domain, startdate, enddate + timedelta(days=1))
heading = "Report for period: " + startdate.strftime('%m/%d/%Y') + " - " + enddate.strftime('%m/%d/%Y')
rendered = reporter.render_direct_sms(data, startdate, enddate,
"hq/reports/sms_organization.txt",
{"heading" : heading })
context['report_display'] = rendered
return render_to_response(request, template_name, context)
def index(req, scope):
''' Display Dashboard '''
summary = {}
if datetime.today().weekday() == 6:
period = ReportPeriod.objects.latest()
else:
period = ReportPeriod.from_day(datetime.today())
summary['period'] = period
summary['total_units'] = len(scope.health_units())
summary['up2date'] = len(filter(lambda hc: hc.up2date(),
scope.health_units()))
summary['missing'] = summary['total_units'] - summary['up2date']
recent = []
for report in EpidemiologicalReport.objects.filter(
_status=EpidemiologicalReport.STATUS_COMPLETED,
clinic__in=scope.health_units())\
.order_by('-completed_on')[:10]:
recent.append({'id': report.id,
'date': report.completed_on.strftime("%a %H:%M"),
'by': ('%s %s' %
(report.completed_by().first_name,
report.completed_by().last_name)).title(),
'by_id': report.completed_by().id,
'clinic': report.clinic,
'clinic_id': report.clinic.id})
return render_to_response(req, 'findug/index.html',
{'summary': summary, 'scope': scope,
'recent': recent})
def export(req, id=None):
t = get_tree(id)
all_states = t.get_all_states()
loops = t.has_loops()
if not loops:
output = StringIO()
w = csv.writer(output)
headings = ["Person", "Date"]
headings.extend([state.question for state in all_states])
w.writerow(headings)
sessions = Session.objects.all().filter(tree=t)
for session in sessions:
values = [str(session.person), session.start_date]
transitions = map((lambda x: x.transition),
session.entry_set.all())
states_w_transitions = {}
for transition in transitions:
states_w_transitions[transition.current_state] = transition
for state in all_states:
if states_w_transitions.has_key(state):
values.append(states_w_transitions[state].answer)
else:
values.append("")
w.writerow(values)
# rewind the virtual file
output.seek(0)
response = HttpResponse(output.read(), mimetype='application/ms-excel')
response[
"content-disposition"] = "attachment; filename=%s.csv" % t.trigger
return response
else:
return render_to_response(req, "tree/index.html", {})
def map(req, scope):
''' Map view '''
if datetime.today().weekday() == 6:
previous_period = ReportPeriod.objects.latest()
else:
previous_period = ReportPeriod.from_day(datetime.today())
all = []
for location in scope.health_units():
loc = {}
loc['obj'] = location
loc['name'] = unicode(location)
loc['type'] = location.type.name.lower().replace(' ', '')
act_reports = ACTConsumptionReport.objects.filter(
reporter__location=location)\
.filter(period=previous_period)
if not act_reports:
loc['act_unknown'] = True
else:
rpt = act_reports[0]
if rpt.yellow_balance:
loc['yellow'] = True
if rpt.blue_balance:
loc['blue'] = True
if rpt.brown_balance:
loc['brown'] = True
if rpt.green_balance:
loc['green'] = True
all.append(loc)
return render_to_response(req, 'findug/map.html',
{'scope': scope, 'locations': all})
def participant_edit(req, id):
reporter = IaviReporter.objects.get(pk=id)
if req.method == 'POST':
form = IaviReporterForm(req.POST)
if form.is_valid():
# Process the data in form.cleaned_data
id = req.POST["reporter_id"]
if not id:
# should puke. should also not be possible through the UI
raise Exception("Reporter ID not set in form. How did you get here?")
reporter = IaviReporter.objects.get(id=id)
reporter.pin = form.cleaned_data["pin"]
reporter.location = form.cleaned_data["location"]
reporter.alias = IaviReporter.get_alias(reporter.location.code, form.cleaned_data["participant_id"])
reporter.save()
conn = reporter.connection()
conn.identity = form.cleaned_data["phone"]
conn.save()
return HttpResponseRedirect('/iavi/participants/%s/' % id)
else:
try:
reporter = IaviReporter.objects.get(pk=id)
if reporter.location:
form = IaviReporterForm(initial={"participant_id" :reporter.study_id, "location" : reporter.location.pk,
"pin" : reporter.pin, "phone" : reporter.connection().identity } )
else:
form = IaviReporterForm({"participant_id" :reporter.study_id,
"pin" : reporter.pin, "phone" : reporter.connection().identity } )
except IaviReporter.NotFound:
form = IaviReporterForm()
template_name="iavi/participant_edit.html"
return render_to_response(req, template_name, {"form" : form, "reporter" : reporter})
def index(req):
template_name="logger/index_flat.html"
columns = (("date", "Date"),
("connection__identity", "From/To"),
("connection__backend", "Backend"),
("is_incoming", "Direction"),
("text", "Message"))
sort_column, sort_descending = _get_sort_info(req, default_sort_column="date",
default_sort_descending=True)
sort_desc_string = "-" if sort_descending else ""
search_string = req.REQUEST.get("q", "")
query = Message.objects.select_related("connection", "connection__backend"
).order_by("%s%s" % (sort_desc_string, sort_column))
if search_string == "":
query = query.all()
else:
query = query.filter(
Q(text__icontains=search_string) |
Q(connection__identity__icontains=search_string))
messages = paginated(req, query)
return render_to_response(req, template_name, {"columns": columns,
"messages": messages,
"sort_column": sort_column,
"sort_descending": sort_descending,
"search_string": search_string})
def annotations(request, attachment_id, allow_add=True):
# TODO: error checking
attach = Attachment.objects.get(id=attachment_id)
annotes = attach.annotations.all()
return render_to_response(request, "receiver/partials/annotations.html", {"attachment": attach,
"annotations": annotes,
"allow_add": allow_add})
def manage_questions(req, id=None):
# no argument = add a question
# and list existing questions
if id is None:
ques = None
# argument = edit an existing
# question (although COMPLEX
# LOGIC will apply here)
else:
ques = get_object_or_404(Question, pk=id)
answers = ques.answers()
# this is really dumb. django templates can't
# deal with arrays, so we're forced to move
# the answers into Q attributes, for now
for n in range(0, len(answers)):
setattr(ques, ("answer_%d" % (n+1)), answers[n])
# otherwise, just render the ADD form
return render_to_response(req, "poll/questions.html", {
"questions": Question.objects.all().order_by("start"),
"question": ques,
"tab": "questions"
})
def single_submission(request, submission_id, template_name="receiver/single_submission.html"):
context = {}
slog = Submission.objects.all().filter(id=submission_id)
context['submission'] = slog[0]
rawstring = str(slog[0].raw_header)
# In order to display the raw header information, we need to
# escape the python object brackets in the output
rawstring = rawstring.replace(': <',': "<')
rawstring = rawstring.replace('>,','>",')
rawstring = rawstring.replace('>}','>"}')
processed_header = eval(rawstring)
get_original = False
for item in request.GET.items():
if item[0] == 'get_original':
get_original = True
if get_original:
response = HttpResponse(mimetype='text/plain')
fin = open(slog[0].raw_post ,'r')
txt = fin.read()
fin.close()
response.write(txt)
return response
attachments = Attachment.objects.all().filter(submission=slog[0])
context ['processed_header'] = processed_header
context['attachments'] = attachments
return render_to_response(request, template_name, context)
def manage_questions(req, id=None):
# no argument = add a question
# and list existing questions
if id is None:
ques = None
# argument = edit an existing
# question (although COMPLEX
# LOGIC will apply here)
else:
ques = get_object_or_404(Question, pk=id)
answers = ques.answers()
# this is really dumb. django templates can't
# deal with arrays, so we're forced to move
# the answers into Q attributes, for now
for n in range(0, len(answers)):
setattr(ques, ("answer_%d" % (n + 1)), answers[n])
# otherwise, just render the ADD form
return render_to_response(
req, "poll/questions.html", {
"questions": Question.objects.all().order_by("start"),
"question": ques,
"tab": "questions"
})
def samples_pop(request):
"""Popup (compact) view a group of samples for a particular day.
"""
date = request.REQUEST.get("date","").split('-')
year = int(date[0])
month = int(date[1]) - 1
day = int(date[2])
area = int(date[3])
count = get_count(day,month,year,area)
date = "%s-%s-%s" % (year,month,day)
template_name="sample_popup.html"
context = {}
context = {
"year":year,
"month": month,
"day":day,
"count": count,
"date":date,
"area":area
}
return render_to_response(request, template_name,context)
def view(request):
"""Calendar view"""
user = request.user
date = datetime.datetime.now()
default = dict(month=date.month, year=date.year, day=1, rowid=1,
name="", desc="", when="", area = 0)
url = request.path
p = getParams(request, default)
year, month, day, area = p['year'], p['month'], p['day'], p['area']
search_string = Facility.objects.all()
location_name = Facility.objects.filter(id = area)
cal = CalendarController(day, area)
cal.load(year, month)
template_name="calendar.html"
context = {}
dict(username=user, cal=cal, url=url)
i = 0
context = {
"username":user,
"cal":cal,
"url":url,
"area":area,
"search_string":search_string,
'i':i,
"location_name":location_name
}
return render_to_response(request, template_name, context)
def toggle(req,status):
if(status):
status = 'On'
else:
status = 'Off'
template_path = "xtrans/index.html"
return render_to_response(req, template_path, {'status':status})
def single_school(req, id, template_name="schools/single_school.html"):
"""View of a single school."""
school = get_object_or_404(School, id=id)
xml_location = "/schools/%s/xml" % id
return render_to_response(req, template_name, {
"school": school,
"xml_location": xml_location
})
def patient_messages(request, pk, template="weltel/patient.html"):
patient = get_object_or_404(Patient, id=pk)
context = {}
context['patient'] = patient
logs = get_messages_for_patient(patient)
if logs:
context['messages'] = paginated(request, logs)
return render_to_response(request, template, context)
def index(req):
tmpls = Template.objects.values_list("key", "text")
tmpl_map = dict([(int(k), t) for k, t in tmpls])
all_tmpls = [{"key": n, "text": tmpl_map.get(n, "")} for n in range(1, 10)]
return render_to_response(req, "training/index.html",
{"templates": all_tmpls})
def patient(request, pk, template="weltel/patient.html"):
patient = get_object_or_404(Patient, id=pk)
context = {}
context['patient'] = patient
logs = get_history_for_patient(patient)
context['history'] = paginated(request, logs)
context['phone_numbers'] = [c.identity for c in patient.connections.all()]
return render_to_response(request, template, context)
def participants(req):
template_name="iavi/participants.html"
user = req.user
try:
profile = user.get_profile()
locations = profile.locations.all()
except IaviProfile.DoesNotExist:
# if they don't have a profile they aren't associated with
# any locations and therefore can't view anything. Only
# exceptions are the superusers
if user.is_superuser:
locations = Location.objects.all()
else:
return render_to_response(req, "iavi/no_profile.html", {})
reporters = IaviReporter.objects.filter(location__in=locations)
return render_to_response(req, template_name, {"reporters" : reporters })
def nurse(request, pk, template="weltel/nurse.html"):
context = {}
nurse = get_object_or_404(Nurse, id=pk)
context['nurse'] = nurse
logs = nurse.messages(order_by='-received')
if logs:
context['logs'] = paginated(request, logs)
context['phone_numbers'] = [c.identity for c in nurse.connections.all()]
return render_to_response(request, template, context)
def site(request, pk, template="weltel/site.html"):
context = {}
site = get_object_or_404(Site, id=pk)
patients = Patient.objects.filter(site=site)
nurses = Nurse.objects.filter(sites=site)
context['site'] = site
context['patients'] = paginated(request, patients)
context['nurses'] = paginated(request, nurses)
return render_to_response(request, template, context)
def participant_summary(req, id):
template_name="iavi/participant_summary.html"
try:
reporter = IaviReporter.objects.get(pk=id)
except IaviReporter.NotFound:
reporter = None
# todo - see if we wnat to put these back in
kenya_reports = KenyaReport.objects.filter(reporter=reporter).order_by("-started")
uganda_reports = UgandaReport.objects.filter(reporter=reporter).order_by("-started")
return render_to_response(req, template_name, {"reporter" : reporter,"kenya_reports":kenya_reports, "uganda_reports":uganda_reports})
def index(req):
template_name = "logger/index.html"
incoming = IncomingMessage.objects.order_by('received')
outgoing = OutgoingMessage.objects.order_by('sent')
all = []
[all.append(msg) for msg in incoming]
[all.append(msg) for msg in outgoing]
# sort by date, descending
all.sort(lambda x, y: cmp(y.date, x.date))
return render_to_response(req, template_name, {"messages": all})
def bednets_daily(req, locid):
if not locid:
locid = 1
try:
location = Location.objects.get(pk=locid)
#_set_stock(location)
except Location.DoesNotExist:
location = None
return render_to_response(req, "bednets/bednets_daily.html",
{'location': location})
def index(request):
'''
Index view
'''
MESSAGES_PER_PAGE = 30
# If it is a POST then they are responding to a message.
# Don't allow sending if the user doesn't have the can_respond permission
if request.method == 'POST' and\
request.user.has_perm('logger_ng.can_respond'):
for field, value in request.POST.iteritems():
match = re.match(r'^respond_(?P<id>\d+)$', field)
if match and len(value) > 1:
pk = match.groupdict()['id']
msg = get_object_or_404(LoggedMessage, pk=pk)
respond_to_msg(msg, value)
return redirect(index)
# Don't exclude outgoing messages that are a response to another,
# because they will be shown threaded beneath the original message
msgs = LoggedMessage.objects.exclude(
direction=LoggedMessage.DIRECTION_OUTGOING, response_to__isnull=False)
# filter from form
if request.method == 'GET':
search = request.GET.get('logger_ng_search_box', '')
msgs = msgs.filter(Q(identity__icontains=search) | \
Q(text__icontains=search) | \
Q(reporter__first_name__icontains=search) | \
Q(reporter__last_name__icontains=search))
msgs = msgs.order_by('-date', 'direction')
paginator = Paginator(msgs, MESSAGES_PER_PAGE)
# Set the pagination page. Go to page 1 in the event there is no page
# get variable or if it's something other than a number.
try:
page = int(request.GET.get('page', '1'))
except ValueError:
page = 1
# Try to set the paginator object to the correct page. Set it to the
# last page if there is some problem with it (too high, etc...)
try:
msgs = paginator.page(page)
except (EmptyPage, InvalidPage):
msgs = paginator.page(paginator.num_pages)
ctx = locals()
ctx['request'] = request
return render_to_response(request, "logger_ng/index.html", ctx)
def index_basic(req):
template_name = "http/setphone.html"
if req.method == 'POST':
phone_number = ''
if req.POST.has_key("phone_number"):
phone_number = req.POST["phone_number"]
if (len(phone_number) == 0):
phone_number = random.randint(100000, 999999)
return HttpResponseRedirect("/httpbasic/%s" % (phone_number))
#return basic_ui(req, phone_number, True)
return render_to_response(req, template_name, {})
def index(req):
filters = {
'period': default_log_period(req),
'location': default_location(req),
'province': default_province(req),
'district': default_district(req)
}
template_name = "logger/index.html"
lox, lxn = 0, location_name(req)
if req.REQUEST.has_key('location') and req.REQUEST['location'] != '0':
lox = int(req.REQUEST['location'])
lxn = Location.objects.get(id=lox)
lxn = lxn.name + ' ' + lxn.type.name + ', ' + lxn.parent.parent.name + ' ' + lxn.parent.parent.type.name + ', ' + lxn.parent.parent.parent.name + ' ' + lxn.parent.parent.parent.type.name
rez = Location.objects.filter(**match_logs(req, filters))
incoming = IncomingMessage.objects.filter(
**match_received(req, filters)).order_by('-received')
outgoing = OutgoingMessage.objects.filter(
**match_sent(req, filters)).order_by('-sent')
all = []
rezf = rez.filter(**match_logs_fresher(req))
for msg in incoming:
if p_location(msg.identity) in rezf: all.append(msg)
for msg in outgoing:
if p_location(msg.identity) in rezf: all.append(msg)
# sort by date, descending
all.sort(lambda x, y: cmp(y.date, x.date))
if req.REQUEST.has_key('csv'):
htp = HttpResponse()
htp['Content-Type'] = 'text/csv; encoding=%s' % (
getdefaultencoding(), )
wrt = csv.writer(htp, dialect='excel-tab')
wrt.writerows(
[['DATE', 'REPORTER', 'BACKEND', 'LOCATION', 'MESSAGE']] +
[[r.date, r.identity, r.backend,
p_location(r.identity), r.text] for r in all])
return htp
else:
return render_to_response(
req, template_name, {
"messages": paginated(req, all, prefix="rep"),
'rez': len(rez),
'rezf': len(rezf),
'usrloc': UserLocation.objects.get(user=req.user),
'start_date': date.strftime(filters['period']['start'],
'%d.%m.%Y'),
'end_date': date.strftime(filters['period']['end'],
'%d.%m.%Y'),
'filters': filters,
'locationname': lxn,
'postqn': (req.get_full_path().split('?', 2) + [''])[1]
})
def password_change(req, id):
user_to_edit = User.objects.get(id=id)
print req.user
if req.method == 'POST':
password_form = AdminPasswordChangeForm(user_to_edit, req.POST)
if password_form.is_valid():
password_form.save()
return HttpResponseRedirect('/iavi/users/%s/edit' % user_to_edit.id)
else:
password_form = AdminPasswordChangeForm(user_to_edit)
template_name="iavi/password_change.html"
return render_to_response(req, template_name, {"current_user" : user_to_edit,
"form" : password_form})
def _old_index(req):
# Reference to the old view of the old tables.
# Ordinarily I would delete this, but this log is still
# around in several deployments
template_name="logger/index.html"
incoming = IncomingMessage.objects.order_by('received')
outgoing = OutgoingMessage.objects.order_by('sent')
all = []
[ all.append(msg) for msg in incoming ]
[ all.append(msg) for msg in outgoing]
# sort by date, descending
all.sort(lambda x, y: cmp(y.date, x.date))
return render_to_response(req, template_name, { "messages": all })
def patient_update(request, patid):
patient = get_object_or_404(Registration, patient_id=patid)
form = PatientForm(instance=patient)
sent = SentNotif.objects.filter(patient_id=patient)
patient.notifications = ', '.join(sorted(
[s.day for s in sent])) if len(sent) > 0 else 'none sent yet'
patient.post_op = (date.today() - patient.registered_on).days
patient.contact_time = '%02d:%02d' % split_contact_time(
patient.contact_time)
return render_to_response(request, 'circumcision/patient.html', {
'px': patient,
'pat_form': form
})
def participant_delete(req, id):
template_name = "iavi/participant_delete.html"
num_reports = 0
try:
reporter = IaviReporter.objects.get(pk=id)
num_reports = len(Report.objects.filter(reporter=reporter))
except IaviReporter.DoesNotExist:
reporter = None
if req.method == 'POST':
if reporter:
reporter.delete()
reporter = None
return render_to_response(req, template_name, {
"reporter": reporter,
"num_reports": num_reports
})
def edit(request, pk, template="scheduler/edit.html"):
context = {}
schedule = get_object_or_404(EventSchedule, id=pk)
if request.method == 'POST':
form = ScheduleForm(request.POST, instance=schedule)
if form.is_valid():
form.save()
context['status'] = _("Schedule '%(name)s' successfully updated" % \
{'name':schedule.callback} )
else:
context['errors'] = form.errors
else:
form = ScheduleForm(instance=schedule)
context['form'] = form
context['schedule'] = schedule
return render_to_response(request, template, context)
