def disease_aggregates(request):
"""
Disease Aggregates Report
"""
if not request.datespan.is_valid():
messages.error(request, request.datespan.get_validation_reason())
return render_to_response(request, "reports/pi_report.html",
{"show_dates": True, "report": None})
clinic_id = request.GET.get("clinic", None)
slug = "disease_aggregate"
results = _pi_results(slug, request.datespan.startdate, request.datespan.enddate,
clinic_id)
main_clinic = Location.objects.get(slug=clinic_id) if clinic_id else None
report = AggregateReport.from_view_results(slug, results)
return render_to_response(request, "reports/pi_report.html",
{"show_dates": False,
"hide_districts": True,
"main_clinic": main_clinic,
"clinics": clinics_for_view(),
"districts": districts_for_view(),
"view_slug": slug,
"report": report})
def resend_confirmation(request):
dom_req = None
try:
dom_req = RegistrationRequest.get_request_for_username(request.user.username)
except Exception:
pass
if not dom_req:
inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False)
if len(inactive_domains_for_user) > 0:
for domain in inactive_domains_for_user:
domain.is_active = True
domain.save()
return redirect('domain_select')
if request.method == 'POST': # If the form has been submitted...
try:
send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid)
except Exception:
vals = {'error_msg':'There was a problem with your request',
'error_details':sys.exc_info(),
'show_homepage_link': 1 }
return render_to_response(request, 'error.html', vals)
else:
vals = dict(alert_message="An email has been sent to %s." % dom_req.new_user_username, requested_domain=dom_req.domain)
return render_to_response(request, 'registration/confirmation_sent.html', vals)
vals = dict(requested_domain=dom_req.domain)
return render_to_response(request, 'registration/confirmation_resend.html', vals)
def register_domain(request):
is_new = False
referer_url = request.GET.get('referer', '')
active_domains_for_user = Domain.active_for_user(request.user)
if len(active_domains_for_user) <= 0 and not request.user.is_superuser:
is_new = True
domains_for_user = Domain.active_for_user(request.user, is_active=False)
if len(domains_for_user) > 0:
vals = dict(requested_domain=domains_for_user[0])
return render_to_response(request, 'registration/confirmation_waiting.html', vals)
if request.method == 'POST': # If the form has been submitted...
nextpage = request.POST.get('next')
org = request.POST.get('org')
form = DomainRegistrationForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
reqs_today = RegistrationRequest.get_requests_today()
max_req = settings.DOMAIN_MAX_REGISTRATION_REQUESTS_PER_DAY
if reqs_today >= max_req:
vals = {'error_msg':'Number of domains requested today exceeds limit ('+str(max_req)+') - contact Dimagi',
'show_homepage_link': 1 }
return render_to_response(request, 'error.html', vals)
request_new_domain(request, form, org, is_new)
requested_domain = form.cleaned_data['domain_name']
if is_new:
vals = dict(alert_message="An email has been sent to %s." % request.user.username, requested_domain=requested_domain)
return render_to_response(request, 'registration/confirmation_sent.html', vals)
else:
messages.success(request, '<strong>The project {project_name} was successfully created!</strong> An email has been sent to {username} for your records.'.format(
username=request.user.username,
project_name=requested_domain
), extra_tags="html")
if nextpage:
return HttpResponseRedirect(nextpage)
if referer_url:
return redirect(referer_url)
return HttpResponseRedirect(reverse("domain_homepage", args=[requested_domain]))
else:
if nextpage:
# messages.error(request, "The new project could not be created! Please make sure to fill out all fields of the form.")
return orgs_landing(request, org, form=form)
else:
form = DomainRegistrationForm() # An unbound form
vals = dict(form=form, is_new=is_new)
return render_to_response(request, 'registration/domain_request.html', vals)
def accept_invitation(request, domain, invitation_id):
if request.GET.get('switch') == 'true':
logout(request)
return redirect_to_login(request.path)
if request.GET.get('create') == 'true':
logout(request)
return HttpResponseRedirect(request.path)
invitation = Invitation.get(invitation_id)
assert(invitation.domain == domain)
if invitation.is_accepted:
messages.error(request, "Sorry that invitation has already been used up. "
"If you feel this is a mistake please ask the inviter for "
"another invitation.")
return HttpResponseRedirect(reverse("login"))
if request.user.is_authenticated():
# if you are already authenticated, just add the domain to your
# list of domains
if request.couch_user.username != invitation.email:
messages.error(request, "The invited user %s and your user %s do not match!" % (invitation.email, request.couch_user.username))
if request.method == "POST":
couch_user = CouchUser.from_django_user(request.user)
couch_user.add_domain_membership(domain=domain)
couch_user.set_role(domain, invitation.role)
couch_user.save()
invitation.is_accepted = True
invitation.save()
messages.success(request, "You have been added to the %s domain" % domain)
return HttpResponseRedirect(reverse("domain_homepage", args=[domain,]))
else:
return render_to_response(request, 'users/accept_invite.html', {'domain': domain,
"invited_user": invitation.email if request.couch_user.username != invitation.email else ""})
else:
# if you're not authenticated we need you to fill out your information
if request.method == "POST":
form = NewWebUserRegistrationForm(request.POST)
if form.is_valid():
user = activate_new_user(form, is_domain_admin=False, domain=invitation.domain)
user.set_role(domain, invitation.role)
user.save()
invitation.is_accepted = True
invitation.save()
messages.success(request, "User account for %s created! You may now login." % form.cleaned_data["email"])
return HttpResponseRedirect(reverse("login"))
else:
form = NewWebUserRegistrationForm(initial={'email': invitation.email})
return render_to_response(request, "users/accept_invite.html", {"form": form})
def add_sample(request, domain, sample_id=None):
sample = None
if sample_id is not None:
sample = SurveySample.get(sample_id)
if request.method == "POST":
form = SurveySampleForm(request.POST)
if form.is_valid():
name = form.cleaned_data.get("name")
sample_contacts = form.cleaned_data.get("sample_contacts")
if sample is None:
sample = SurveySample (
domain = domain,
name = name,
contacts = sample_contacts
)
else:
sample.name = name
sample.contacts = sample_contacts
sample.save()
return HttpResponseRedirect(reverse("sample_list", args=[domain]))
else:
initial = {}
if sample is not None:
initial["name"] = sample.name
initial["sample_contacts"] = sample.contacts
form = SurveySampleForm(initial=initial)
context = {
"domain" : domain,
"form" : form,
"sample_id" : sample_id
}
return render_to_response(request, "reminders/partial/add_sample.html", context)
def add_survey(request, domain, survey_id=None):
survey = None
if survey_id is not None:
survey = Survey.get(survey_id)
if request.method == "POST":
form = SurveyForm(request.POST)
if form.is_valid():
name = form.cleaned_data.get("name")
waves = form.cleaned_data.get("waves")
followups = form.cleaned_data.get("followups")
samples = form.cleaned_data.get("samples")
send_automatically = form.cleaned_data.get("send_automatically")
send_followup = form.cleaned_data.get("send_followup")
if survey is None:
survey = Survey (
domain = domain,
name = name,
waves = waves,
followups = followups,
samples = samples,
send_automatically = send_automatically,
send_followup = send_followup
)
else:
survey.name = name
survey.waves = waves
survey.followups = followups
survey.samples = samples
survey.send_automatically = send_automatically
survey.send_followup = send_followup
survey.save()
return HttpResponseRedirect(reverse("survey_list", args=[domain]))
else:
initial = {}
if survey is not None:
initial["name"] = survey.name
initial["waves"] = survey.waves
initial["followups"] = survey.followups
initial["samples"] = survey.samples
initial["send_automatically"] = survey.send_automatically
initial["send_followup"] = survey.send_followup
form = SurveyForm(initial=initial)
form_list = get_form_list(domain)
form_list.insert(0, {"code":"--choose--", "name":"-- Choose --"})
sample_list = get_sample_list(domain)
sample_list.insert(0, {"code":"--choose--", "name":"-- Choose --"})
context = {
"domain" : domain,
"survey_id" : survey_id,
"form" : form,
"form_list" : form_list,
"sample_list" : sample_list,
"method_list" : SURVEY_METHOD_LIST,
"user_list" : CommCareUser.by_domain(domain),
}
return render_to_response(request, "reminders/partial/add_survey.html", context)
def manage_multimedia(request, domain):
media = request.project.all_media()
if request.method == "POST":
for m_file in media:
if '%s_tags' % m_file._id in request.POST:
m_file.tags[domain] = request.POST.get('%s_tags' % m_file._id, '').split(' ')
if domain not in m_file.shared_by and request.POST.get('%s_shared' % m_file._id, False):
m_file.shared_by.append(domain)
elif domain in m_file.shared_by and not request.POST.get('%s_shared' % m_file._id, False):
m_file.shared_by.remove(domain)
if '%s_license' % m_file._id in request.POST:
m_file.licenses[domain] = request.POST.get('%s_license' % m_file._id, 'public')
m_file.save()
messages.success(request, "Multimedia updated successfully!")
return render_to_response(request, 'domain/admin/media_manager.html', {'domain': domain,
'media': [{
'license': m.licenses.get(domain, 'public'),
'shared': domain in m.shared_by,
'url': m.url(),
'm_id': m._id,
'tags': m.tags.get(domain, []),
'type': m.doc_type
} for m in media],
'licenses': LICENSES.items()
})
def case_details(request, domain, case_id):
timezone = util.get_timezone(request.couch_user.user_id, domain)
try:
case = CommCareCase.get(case_id)
report_name = 'Details for Case "%s"' % case.name
except ResourceNotFound:
messages.info(request, "Sorry, we couldn't find that case. If you think this is a mistake plase report an issue.")
return HttpResponseRedirect(inspect.SubmitHistory.get_url(domain))
form_lookups = dict((form.get_id,
"%s: %s" % (form.received_on.date(),
xmlns_to_name(domain, form.xmlns, get_app_id(form)))) \
for form in case.get_forms())
return render_to_response(request, "reports/reportdata/case_details.html", {
"domain": domain,
"case_id": case_id,
"form_lookups": form_lookups,
"slug":inspect.CaseListReport.slug,
"report": dict(
name=report_name,
slug=inspect.CaseListReport.slug,
is_async=False,
),
"layout_flush_content": True,
"timezone": timezone
})
def list_chws(request):
"""
List chws
"""
chws = CommunityHealthWorker.view("chw/by_clinic", include_docs=True)
return render_to_response(request, "chw/chw_list.html",
{"chws": chws})
def invite_web_user(request, domain, template="users/invite_web_user.html"):
role_choices = UserRole.role_choices(domain)
if request.method == "POST":
form = AdminInvitesUserForm(request.POST,
excluded_emails=[user.username for user in WebUser.by_domain(domain)],
role_choices=role_choices
)
if form.is_valid():
data = form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = domain
invite = Invitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse("web_users", args=[domain]))
else:
form = AdminInvitesUserForm(role_choices=role_choices)
context = _users_context(request, domain)
context.update(
registration_form=form
)
return render_to_response(request, template, context)
def power_down(req):
if settings.BHOMA_CAN_POWER_DOWN_SERVER:
shutdown(settings.SHUTDOWN_DELAY)
return render_to_response(req, "touchscreen/shutdown.html", {
'buffer': settings.SHUTDOWN_BUFFER, 'timeout': settings.SHUTDOWN_TIMEOUT})
else:
raise Exception('server does not support remote shutdown')
def case_list(request, domain):
apps = filter(lambda app: app.doc_type == "Application",
ApplicationBase.view('app_manager/applications_brief',
startkey=[domain], endkey=[domain, {}]))
user_id = request.REQUEST.get("user_id", request.couch_user.get_id)
app_id = request.REQUEST.get("app_id", "")
module_id = int(request.REQUEST.get("module_id", "0"))
language = request.REQUEST.get("language", "en")
if not app_id and apps:
app_id = apps[0].get_id
if app_id:
app = Application.get(app_id)
case_short = app.modules[module_id].get_detail("case_short")
case_long = app.modules[module_id].get_detail("case_long")
else:
case_short=""
case_long=""
return render_to_response(request, "cloudcare/list_cases.html",
{"domain": domain,
"language": language,
"user_id": user_id,
"apps": apps,
"case_short": json.dumps(case_short._doc),
"case_long": json.dumps(case_long._doc),
"cases": json.dumps(get_owned_cases(domain, user_id),
default=json_handler)})
def app_list(request, domain, urlPath):
preview = string_to_boolean(request.REQUEST.get("preview", "false"))
language = request.couch_user.language or "en"
def _app_latest_build_json(app_id):
build = ApplicationBase.view('app_manager/saved_app',
startkey=[domain, app["_id"], {}],
endkey=[domain, app["_id"]],
descending=True,
limit=1).one()
return build._doc if build else None
if not preview:
apps = get_cloudcare_apps(domain)
# replace the apps with the last build of each app
apps = [_app_latest_build_json(app["_id"])for app in apps]
else:
apps = ApplicationBase.view('app_manager/applications_brief', startkey=[domain], endkey=[domain, {}])
apps = [app._doc for app in apps if app and app.application_version == "2.0"]
# trim out empty apps
apps = filter(lambda app: app, apps)
return render_to_response(request, "cloudcare/cloudcare_home.html",
{"domain": domain,
"language": language,
"apps": json.dumps(apps),
"apps_raw": apps,
"preview": preview,
"maps_api_key": settings.GMAPS_API_KEY })
def single_patient(request, patient_id):
patient = loader.get_patient(patient_id)
xforms = CXFormInstance.view("patient/xforms", key=patient.get_id, include_docs=True)
encounter_types = get_encounters(patient)
options = TouchscreenOptions.default()
# TODO: are we upset about how this breaks MVC?
options.nextbutton.show = False
options.backbutton = ButtonOptions(text="BACK",
link=reverse("patient_select"))
encounters = sorted(patient.encounters, key=lambda encounter: encounter.visit_date, reverse=True)
# TODO: figure out a way to do this more centrally
# Inject cases into encounters so we can show them linked in the view
for encounter in patient.encounters:
if encounter.get_xform():
encounter.dynamic_data["classification"] = get_classification(encounter.get_xform().namespace)
encounter.dynamic_data["cases"] = []
for case in patient.cases:
if case.encounter_id == encounter.get_id:
encounter.dynamic_data["cases"].append(case)
return render_to_response(request, "patient/single_patient_touchscreen.html",
{"patient": patient,
"encounters": encounters,
"xforms": xforms,
"encounter_types": encounter_types,
"options": options })
def export_data(request):
# HACK this is hardcoded to something in the DB
export_group = GroupExportConfiguration.get("export_all_forms")
return render_to_response(request, "patient/export_data.html",
{"clinic_encounters": CLINIC_ENCOUNTERS,
"chw_encounters": CHW_ENCOUNTERS,
"group": export_group})
def orgs_team_members(request, org, team_id, template="orgs/orgs_team_members.html"):
#organization and teams
organization = Organization.get_by_name(org)
teams = Team.get_by_org(org)
current_domains = Domain.get_by_organization(org)
#check that the team exists
team = Team.get(team_id)
if team is None:
raise Http404("Group %s does not exist" % team_id)
#inspect the members of the team
member_ids = team.get_member_ids()
members = WebUser.view("_all_docs", keys=member_ids, include_docs=True).all()
members.sort(key=lambda user: user.username)
#inspect the domains of the team
domain_names = team.get_domains()
domains = list()
for name in domain_names:
domains.append([Domain.get_by_name(name), team.role_label(domain=name)])
all_org_domains = Domain.get_by_organization(org)
non_domains = [domain for domain in all_org_domains if domain.name not in domain_names]
all_org_member_ids = organization.members
all_org_members = WebUser.view("_all_docs", keys=all_org_member_ids, include_docs=True).all()
non_members = [member for member in all_org_members if member.user_id not in member_ids]
vals = dict(org=organization, team=team, teams=teams, members=members, nonmembers=non_members, domains=current_domains, team_domains=domains, team_nondomains=non_domains)
return render_to_response(request, template, vals)
def upload(request, domain, app_id):
app = get_app(domain, app_id)
DNS_name = "http://"+Site.objects.get(id = settings.SITE_ID).domain
return render_to_response(request, "hqmedia/bulk_upload.html",
{"domain": domain,
"app": app,
"DNS_name": DNS_name})
def scheduled_reminders(request, domain, template="reminders/partial/scheduled_reminders.html"):
reminders = CaseReminderHandler.get_all_reminders(domain)
dates = []
now = datetime.utcnow()
today = now.date()
if reminders:
start_date = reminders[0].next_fire.date()
if today < start_date:
start_date = today
end_date = reminders[-1].next_fire.date()
else:
start_date = end_date = today
# make sure start date is a Monday and enddate is a Sunday
start_date -= timedelta(days=start_date.weekday())
end_date += timedelta(days=6-end_date.weekday())
while start_date <= end_date:
dates.append(start_date)
start_date += timedelta(days=1)
return render_to_response(request, template, {
'domain': domain,
'reminders': reminders,
'dates': dates,
'today': today,
'now': now,
})
def touchscreen_login(request):
'''Login to bhoma via touchscreen'''
if request.method == "POST":
data = json.loads(request.POST.get('result'))
if not data:
return HttpResponseRedirect('/') #TODO: where should this go? some sort of 'welcome' screen?
username = data.get("username")
password = data.get("password")
user = authenticate(username=username, password=password)
if user is None:
# HACK try lowercase
user = authenticate(username=username, password=password.lower())
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse("landing_page"))
else:
return HttpResponseNotAllowed("Sorry %s's account has been disabled" % username)
else:
return HttpResponseForbidden("Sorry that wasn't the right username or password")
return render_to_response(request, "bhoma_touchscreen.html",
{'form': {'name': 'login',
'wfobj': 'wfLogin'},
'mode': 'workflow',
'dynamic_scripts': ["%swebapp/javascripts/login.js" % \
settings.STATIC_URL,] })
def commcare_version_report(request, template="hqadmin/commcare_version.html"):
apps = get_db().view("app_manager/applications_brief").all()
menu = CommCareBuildConfig.fetch().menu
builds = [item.build.to_string() for item in menu]
by_build = dict([(item.build.to_string(), {"label": item.label, "apps": []}) for item in menu])
for app in apps:
app = app["value"]
app["id"] = app["_id"]
if app.get("build_spec"):
build_spec = BuildSpec.wrap(app["build_spec"])
build = build_spec.to_string()
if by_build.has_key(build):
by_build[build]["apps"].append(app)
else:
by_build[build] = {"label": build_spec.get_label(), "apps": [app]}
builds.append(build)
tables = []
for build in builds:
by_build[build]["build"] = build
tables.append(by_build[build])
context = get_hqadmin_base_context(request)
context.update({"tables": tables})
context["hide_filters"] = True
return render_to_response(request, template, context)
def message_log_report(request):
show_dates = True
datespan = request.datespan
domains = Domain.get_all()
for dom in domains:
dom.sms_incoming = SMSLog.count_incoming_by_domain(dom.name, datespan.startdate_param, datespan.enddate_param)
dom.sms_outgoing = SMSLog.count_outgoing_by_domain(dom.name, datespan.startdate_param, datespan.enddate_param)
dom.sms_total = SMSLog.count_by_domain(dom.name, datespan.startdate_param, datespan.enddate_param)
context = get_hqadmin_base_context(request)
headers = DataTablesHeader(
DataTablesColumn("Domain"),
DataTablesColumn("Incoming Messages", sort_type=DTSortType.NUMERIC),
DataTablesColumn("Outgoing Messages", sort_type=DTSortType.NUMERIC),
DataTablesColumn("Total Messages", sort_type=DTSortType.NUMERIC),
)
context["headers"] = headers
context["aoColumns"] = headers.render_aoColumns
context.update({"domains": domains, "show_dates": show_dates, "datespan": datespan})
context["layout_flush_content"] = True
return render_to_response(request, "hqadmin/message_log_report.html", context)
def domain_list(request):
# one wonders if this will eventually have to paginate
domains = Domain.get_all()
all_stats = _all_domain_stats()
for dom in domains:
dom.web_users = int(all_stats["web_users"][dom.name])
dom.commcare_users = int(all_stats["commcare_users"][dom.name])
dom.cases = int(all_stats["cases"][dom.name])
dom.forms = int(all_stats["forms"][dom.name])
dom.admins = [
row["doc"]["email"]
for row in get_db().view("users/admins_by_domain", key=dom.name, reduce=False, include_docs=True).all()
]
context = get_hqadmin_base_context(request)
context.update({"domains": domains})
context["layout_flush_content"] = True
headers = DataTablesHeader(
DataTablesColumn("Domain"),
DataTablesColumn("# Web Users", sort_type=DTSortType.NUMERIC),
DataTablesColumn("# Mobile Workers", sort_type=DTSortType.NUMERIC),
DataTablesColumn("# Cases", sort_type=DTSortType.NUMERIC),
DataTablesColumn("# Submitted Forms", sort_type=DTSortType.NUMERIC),
DataTablesColumn("Domain Admins"),
)
context["headers"] = headers
context["aoColumns"] = headers.render_aoColumns
return render_to_response(request, "hqadmin/domain_list.html", context)
def commcare_users(request, domain, template="users/commcare_users.html"):
show_inactive = json.loads(request.GET.get('show_inactive', 'false'))
sort_by = request.GET.get('sortBy', 'abc')
cannot_share = json.loads(request.GET.get('cannot_share', 'false'))
show_more_columns = request.GET.get('show_more_columns') is not None
context = _users_context(request, domain)
if cannot_share:
users = CommCareUser.cannot_share(domain)
else:
users = CommCareUser.by_domain(domain)
if show_inactive:
users.extend(CommCareUser.by_domain(domain, is_active=False))
if sort_by == 'forms':
users.sort(key=lambda user: -user.form_count)
context.update({
'commcare_users': users,
'groups': Group.get_case_sharing_groups(domain),
'show_case_sharing': request.project.case_sharing_included(),
'show_inactive': show_inactive,
'cannot_share': cannot_share,
'show_more_columns': show_more_columns or cannot_share,
})
return render_to_response(request, template, context)
def register_org(request, template="registration/org_request.html"):
referer_url = request.GET.get('referer', '')
if request.method == "POST":
form = OrganizationRegistrationForm(request.POST, request.FILES)
if form.is_valid():
name = form.cleaned_data["org_name"]
title = form.cleaned_data["org_title"]
email = form.cleaned_data["email"]
url = form.cleaned_data["url"]
location = form.cleaned_data["location"]
logo = form.cleaned_data["logo"]
if logo:
logo_filename = logo.name
else:
logo_filename = ''
org = Organization(name=name, title=title, location=location, email=email, url=url, logo_filename=logo_filename)
org.save()
if logo:
org.put_attachment(content=logo.read(), name=logo.name)
if referer_url:
return redirect(referer_url)
return HttpResponseRedirect(reverse("orgs_landing", args=[name]))
else:
form = OrganizationRegistrationForm() # An unbound form
vals = dict(form=form)
return render_to_response(request, template, vals)
def single(request, chw_id):
"""
Single CHW
"""
chw = CommunityHealthWorker.get(chw_id)
return render_to_response(request, "chw/single_chw.html",
{"chw": chw })
def add_scheduled_report(request, user_id):
recipient = User.objects.get(pk=user_id)
if request.method == "POST":
report_id = request.POST["report_id"]
hour = request.POST["hour"]
day = request.POST["day"]
if day=="all":
report = DailyReportSubscription()
elif day=="first":
report = MonthlyReportSubscription()
report.day_of_month = 1
else:
report = WeeklyReportSubscription()
report.day_of_week = int(day)
report.hours = int(hour)
report.report = SchedulableReport.objects.get(pk=report_id)
# not generic
location_code = request.POST["location_code"]
report.view_args = {'location_code':location_code}
report.save()
report.users.add(recipient)
report.save()
messages.success(request, "New scheduled report added!")
return HttpResponseRedirect(reverse("email_reports"))
context = {}
context.update({"hours": [(val, "%s:00" % val) for val in range(24)],
"days": [(val, calendar.day_name[val]) for val in range(7)],
"reports": SchedulableReport.objects.all()})
# here we get less generic : b
context['locations'] = Location.objects.all()
context['recipient'] = recipient
return render_to_response(request, "reports/add_scheduled_report.html", context)
def appstore(request, template="appstore/appstore_base.html", sort_by=None):
page = int(request.GET.get('page', 1))
include_unapproved = (request.user.is_superuser and request.GET.get('unapproved', False))
if not sort_by:
results = Domain.published_snapshots(include_unapproved=include_unapproved, page=page, per_page=PER_PAGE)
more_pages = page * PER_PAGE < results.total_rows and len(results) == PER_PAGE # hacky way to deal with approved vs unapproved
else:
total_results = Domain.published_snapshots(include_unapproved=include_unapproved)
if sort_by == 'best':
results = Domain.popular_sort(total_results, page)
#more_pages = page * PER_PAGE < total_results and page <= 10
elif sort_by == 'hits':
results = Domain.hit_sort(total_results, page)
#more_pages = page * PER_PAGE < len(total_results) and page <= 10
more_pages = page * PER_PAGE < total_results.total_rows and len(results) == PER_PAGE # hacky way to deal with approved vs unapproved
average_ratings = list()
for result in results:
average_ratings.append([result.name, Review.get_average_rating_by_app(result.original_doc)])
return render_to_response(request, template, _appstore_context({
'apps': results,
'average_ratings': average_ratings,
'page': page,
'prev_page': (page-1),
'next_page': (page+1),
'more_pages': more_pages,
'sort_by': sort_by,
'include_unapproved': include_unapproved
}))
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 not domains_for_user:
return redirect('registration_domain')
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.
domain = form.cleaned_data['domain_list'].name
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = reverse('domain_homepage', args=[domain])
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 list_reminders(request, domain, template="reminders/partial/list_reminders.html"):
handlers = CaseReminderHandler.get_handlers(domain=domain).all()
print handlers
return render_to_response(request, template, {
'domain': domain,
'reminder_handlers': handlers
})
def delete_all_data(request, domain, template="cleanup/delete_all_data.html"):
if request.method == 'GET':
return render_to_response(request, template, {
'domain': domain
})
xforms = XFormInstance.view('reports/all_submissions',
startkey=[domain],
endkey=[domain, {}],
include_docs=True,
reduce=False
)
cases = CommCareCase.view('case/by_date_modified',
startkey=[domain, {}, {}],
endkey=[domain, {}, {}, {}],
include_docs=True,
reduce=False
)
suffix = DELETED_SUFFIX
deletion_id = random_hex()
for thing_list in (xforms, cases):
for thing in thing_list:
thing.doc_type += suffix
thing['-deletion_id'] = deletion_id
thing.save()
return HttpResponseRedirect(reverse('homepage'))
