def export_list(request, username, id_string, export_type):
if export_type == Export.GDOC_EXPORT:
redirect_url = reverse(
export_list,
kwargs={
'username': username, 'id_string': id_string,
'export_type': export_type})
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if should_create_new_export(xform, export_type):
try:
create_async_export(
xform, export_type, query=None, force_xlsx=True)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
context = RequestContext(request)
context.username = owner.username
context.xform = xform
# TODO: better output e.g. Excel instead of XLS
context.export_type = export_type
context.export_type_name = Export.EXPORT_TYPE_DICT[export_type]
exports = Export.objects.filter(xform=xform, export_type=export_type)\
.order_by('-created_on')
context.exports = exports
return render_to_response('export_list.html', context_instance=context)
def kml_export(request, username, id_string):
# read the locations from the database
context = RequestContext(request)
context.message = "HELLO!!"
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context.data = kml_export_data(id_string, user=owner)
response = \
render_to_response("survey.kml", context_instance=context,
mimetype="application/vnd.google-earth.kml+xml")
response['Content-Disposition'] = \
disposition_ext_and_date(id_string, 'kml')
audit = {
"xform": xform.id_string,
"export_type": Export.KML_EXPORT
}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created KML export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
}, audit, request)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded KML export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
}, audit, request)
return response
def map_view(request, username, id_string):
xform = XForm.objects.get(user__username=username, id_string=id_string)
owner = User.objects.get(username=username)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
context = RequestContext(request)
context.content_user = owner
context.xform = xform
context.profile, created = UserProfile.objects.get_or_create(user=owner)
points = ParsedInstance.objects.values('lat', 'lng', 'instance').filter(
instance__user=owner,
instance__xform__id_string=id_string,
lat__isnull=False,
lng__isnull=False)
center = {
'lat': round_down_geopoint(average([p['lat'] for p in points])),
'lng': round_down_geopoint(average([p['lng'] for p in points])),
}
def round_down_point(p):
return {
'lat': round_down_geopoint(p['lat']),
'lng': round_down_geopoint(p['lng']),
'instance': p['instance']
}
context.points = json.dumps([round_down_point(p) for p in list(points)])
context.center = json.dumps(center)
context.form_view = True
return render_to_response('map.html', context_instance=context)
def zip_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if request.GET.get('raw'):
id_string = None
attachments = Attachment.objects.filter(instance__xform=xform)
zip_file = create_attachments_zipfile(attachments)
audit = {"xform": xform.id_string, "export_type": Export.ZIP_EXPORT}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created ZIP export on '%(id_string)s'.") % {
'id_string': xform.id_string,
}, audit, request)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded ZIP export on '%(id_string)s'.") % {
'id_string': xform.id_string,
}, audit, request)
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name('zip',
id_string,
file_path=zip_file,
use_local_filesystem=True)
return response
def map_view(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u"Not shared."))
context = RequestContext(request)
context.content_user = owner
context.xform = xform
context.profile, created = UserProfile.objects.get_or_create(user=owner)
points = ParsedInstance.objects.values("lat", "lng", "instance").filter(
instance__user=owner, instance__xform__id_string=id_string, lat__isnull=False, lng__isnull=False
)
center = {
"lat": round_down_geopoint(average([p["lat"] for p in points])),
"lng": round_down_geopoint(average([p["lng"] for p in points])),
}
def round_down_point(p):
return {"lat": round_down_geopoint(p["lat"]), "lng": round_down_geopoint(p["lng"]), "instance": p["instance"]}
context.center = json.dumps(center)
context.form_view = True
context.jsonform_url = reverse(download_jsonform, kwargs={"username": username, "id_string": id_string})
context.mongo_api_url = reverse(main.views.api, kwargs={"username": username, "id_string": id_string})
context.mapbox_layer = MetaData.mapbox_layer_upload(xform)
return render_to_response("map.html", context_instance=context)
def enter_data(request, username, id_string):
owner = User.objects.get(username=username)
xform = get_object_or_404(XForm, user__username=username, id_string=id_string)
if not has_permission(xform, owner, request):
return HttpResponseForbidden("Not shared.")
if not hasattr(settings, "TOUCHFORMS_URL"):
return HttpResponseRedirect(reverse("main.views.show", kwargs={"username": username, "id_string": id_string}))
url = settings.TOUCHFORMS_URL
register_openers()
response = None
with tempfile.TemporaryFile() as tmp:
tmp.write(xform.xml.encode("utf-8"))
tmp.seek(0)
values = {"file": tmp, "format": "json", "uuid": xform.uuid}
data, headers = multipart_encode(values)
headers["User-Agent"] = "formhub"
req = urllib2.Request(url, data, headers)
try:
response = urllib2.urlopen(req)
response = json.loads(response.read())
context = RequestContext(request)
owner = User.objects.get(username=username)
context.profile, created = UserProfile.objects.get_or_create(user=owner)
context.xform = xform
context.content_user = owner
context.form_view = True
context.touchforms = response["url"]
return render_to_response("form_entry.html", context_instance=context)
# return HttpResponseRedirect(response['url'])
except urllib2.URLError:
pass # this will happen if we could not connect to touchforms
return HttpResponseRedirect(reverse("main.views.show", kwargs={"username": username, "id_string": id_string}))
def delete_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
export_id = request.POST.get('export_id')
# find the export entry in the db
export = get_object_or_404(Export, id=export_id)
export.delete()
audit = {"xform": xform.id_string, "export_type": export.export_type}
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Deleted %(export_type)s export '%(filename)s'"
" on '%(id_string)s'.") % {
'export_type': export.export_type.upper(),
'filename': export.filename,
'id_string': xform.id_string,
}, audit, request)
return HttpResponseRedirect(
reverse(export_list,
kwargs={
"username": username,
"id_string": id_string,
"export_type": export_type
}))
def zip_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
dd = DataDictionary.objects.get(id_string=id_string,
user=owner)
if request.GET.get('raw'):
id_string = None
# create zip_file
tmp = NamedTemporaryFile()
z = zipfile.ZipFile(tmp, 'w', zipfile.ZIP_DEFLATED)
photos = image_urls_for_form(xform)
for photo in photos:
f = NamedTemporaryFile()
req = urllib2.Request(photo)
f.write(urllib2.urlopen(req).read())
f.seek(0)
z.write(f.name, urlparse(photo).path[1:])
f.close()
z.close()
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name('zip', id_string,
file_path=tmp.name, use_local_filesystem=True)
return response
def export_list(request, username, id_string, export_type):
if export_type == Export.GDOC_EXPORT:
redirect_url = reverse(
export_list,
kwargs={
'username': username, 'id_string': id_string,
'export_type': export_type})
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if should_create_new_export(xform, export_type):
try:
create_async_export(
xform, export_type, query=None, force_xlsx=True)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
context = RequestContext(request)
context.username = owner.username
context.xform = xform
# TODO: better output e.g. Excel instead of XLS
context.export_type = export_type
context.export_type_name = Export.EXPORT_TYPE_DICT[export_type]
exports = Export.objects.filter(xform=xform, export_type=export_type)\
.order_by('-created_on')
context.exports = exports
return render_to_response('export_list.html', context_instance=context)
def delete_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
export_id = request.POST.get('export_id')
# find the export entry in the db
export = get_object_or_404(Export, id=export_id)
export.delete()
audit = {
"xform": xform.id_string,
"export_type": export.export_type
}
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Deleted %(export_type)s export '%(filename)s'"
" on '%(id_string)s'.") %
{
'export_type': export.export_type.upper(),
'filename': export.filename,
'id_string': xform.id_string,
}, audit, request)
return HttpResponseRedirect(reverse(
export_list,
kwargs={
"username": username,
"id_string": id_string,
"export_type": export_type
}))
def export_progress(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
# find the export entry in the db
export_ids = request.GET.getlist('export_ids')
exports = Export.objects.filter(xform=xform, id__in=export_ids)
statuses = []
for export in exports:
status = {
'complete': False,
'url': None,
'filename': None,
'export_id': export.id
}
if export.status == Export.SUCCESSFUL:
status['url'] = reverse(export_download, kwargs={
'username': owner.username,
'id_string': xform.id_string,
'export_type': export.export_type,
'filename': export.filename
})
status['filename'] = export.filename
# mark as complete if it either failed or succeeded but NOT pending
if export.status == Export.SUCCESSFUL or export.status == Export.FAILED:
status['complete'] = True
statuses.append(status)
return HttpResponse(simplejson.dumps(statuses), mimetype='application/json')
def kml_export(request, username, id_string):
# read the locations from the database
context = RequestContext(request)
context.message = "HELLO!!"
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context.data = kml_export_data(id_string, user=owner)
response = \
render_to_response("survey.kml", context_instance=context,
mimetype="application/vnd.google-earth.kml+xml")
response['Content-Disposition'] = \
disposition_ext_and_date(id_string, 'kml')
audit = {"xform": xform.id_string, "export_type": Export.KML_EXPORT}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created KML export on '%(id_string)s'.") % {
'id_string': xform.id_string,
}, audit, request)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded KML export on '%(id_string)s'.") % {
'id_string': xform.id_string,
}, audit, request)
return response
def export_download(request, username, id_string, export_type, filename):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
# find the export entry in the db
export = get_object_or_404(Export, xform=xform, filename=filename)
if export_type == Export.GDOC_EXPORT and export.export_url is not None:
return HttpResponseRedirect(export.export_url)
ext, mime_type = export_def_from_filename(export.filename)
audit = {
"xform": xform.id_string,
"export_type": export.export_type
}
audit_log(Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded %(export_type)s export '%(filename)s' on '%(id_string)s'.") %\
{
'export_type': export.export_type.upper(),
'filename': export.filename,
'id_string': xform.id_string,
}, audit, request)
if request.GET.get('raw'):
id_string = None
basename = os.path.splitext(export.filename)[0]
response = response_with_mimetype_and_name(
mime_type, name=basename, extension=ext,
file_path=export.filepath, show_date=False)
return response
def map_view(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
context = RequestContext(request)
context.content_user = owner
context.xform = xform
context.profile, created = UserProfile.objects.get_or_create(user=owner)
points = ParsedInstance.objects.values('lat', 'lng', 'instance').filter(
instance__user=owner,
instance__xform__id_string=id_string,
lat__isnull=False,
lng__isnull=False)
center = {
'lat': round_down_geopoint(average([p['lat'] for p in points])),
'lng': round_down_geopoint(average([p['lng'] for p in points])),
}
def round_down_point(p):
return {
'lat': round_down_geopoint(p['lat']),
'lng': round_down_geopoint(p['lng']),
'instance': p['instance']
}
context.center = json.dumps(center)
context.form_view = True
context.jsonform_url = reverse(download_jsonform, \
kwargs={"username": username, "id_string":id_string})
context.mongo_api_url = reverse(main.views.api, \
kwargs={"username": username, "id_string": id_string})
context.mapbox_layer = MetaData.mapbox_layer_upload(xform)
return render_to_response('map.html', context_instance=context)
def google_xls_export(request, username, id_string):
token = None
if request.user.is_authenticated():
try:
ts = TokenStorageModel.objects.get(id=request.user)
except TokenStorageModel.DoesNotExist:
pass
else:
token = ts.token
elif request.session.get("access_token"):
token = request.session.get("access_token")
if token is None:
request.session["google_redirect_url"] = reverse(
google_xls_export, kwargs={"username": username, "id_string": id_string}
)
return HttpResponseRedirect(redirect_uri)
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u"Not shared."))
valid, dd = dd_for_params(id_string, owner, request)
if not valid:
return dd
ddw = XlsWriter()
tmp = NamedTemporaryFile(delete=False)
ddw.set_file(tmp)
ddw.set_data_dictionary(dd)
temp_file = ddw.save_workbook_to_file()
temp_file.close()
url = google_export_xls(tmp.name, xform.title, token, blob=True)
os.unlink(tmp.name)
return HttpResponseRedirect(url)
def download_xlsform(request, username, id_string):
xform = get_object_or_404(XForm,
user__username=username, id_string=id_string)
owner = User.objects.get(username=username)
helper_auth_helper(request)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden('Not shared.')
file_path = xform.xls.name
default_storage = get_storage_class()()
if default_storage.exists(file_path):
audit = {
"xform": xform.id_string
}
audit_log(
Actions.FORM_XLS_DOWNLOADED, request.user, xform.user,
_("Downloaded XLS file for form '%(id_string)s'.") %
{
"id_string": xform.id_string
}, audit, request)
split_path = file_path.split(os.extsep)
extension = 'xls'
if len(split_path) > 1:
extension = split_path[len(split_path) - 1]
response = response_with_mimetype_and_name(
'vnd.ms-excel', id_string, show_date=False, extension=extension,
file_path=file_path)
return response
else:
messages.add_message(request, messages.WARNING,
_(u'No XLS file for your form '
u'<strong>%(id)s</strong>')
% {'id': id_string})
return HttpResponseRedirect("/%s" % username)
def zip_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
dd = DataDictionary.objects.get(id_string=id_string,
user=owner)
if request.GET.get('raw'):
id_string = None
# create zip_file
tmp = NamedTemporaryFile()
z = zipfile.ZipFile(tmp, 'w', zipfile.ZIP_DEFLATED)
photos = image_urls_for_form(xform)
for photo in photos:
f = NamedTemporaryFile()
req = urllib2.Request(photo)
f.write(urllib2.urlopen(req).read())
f.seek(0)
z.write(f.name, urlparse(photo).path[1:])
f.close()
z.close()
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name('zip', id_string,
file_path=tmp.name,
use_local_filesystem=True)
return response
def create_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
query = request.POST.get("query")
force_xlsx = request.POST.get('xlsx') == 'true'
try:
create_async_export(xform, export_type, query, force_xlsx)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
else:
audit = {
"xform": xform.id_string,
"export_type": export_type
}
audit_log(Actions.EXPORT_CREATED, request.user, owner,
_("Created %(export_type)s export on '%(id_string)s'.") %\
{
'export_type': export_type.upper(),
'id_string': xform.id_string,
}, audit, request)
return HttpResponseRedirect(reverse(
export_list,
kwargs={
"username": username,
"id_string": id_string,
"export_type": export_type
})
)
def zip_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if request.GET.get('raw'):
id_string = None
attachments = Attachment.objects.filter(instance__xform=xform)
zip_file = create_attachments_zipfile(attachments)
audit = {
"xform": xform.id_string,
"export_type": Export.ZIP_EXPORT
}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created ZIP export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
}, audit, request)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded ZIP export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
}, audit, request)
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name('zip', id_string,
file_path=zip_file,
use_local_filesystem=True)
return response
def download_xlsform(request, username, id_string):
xform = get_object_or_404(XForm,
user__username=username,
id_string=id_string)
owner = User.objects.get(username=username)
helper_auth_helper(request)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden('Not shared.')
file_path = xform.xls.name
default_storage = get_storage_class()()
if default_storage.exists(file_path):
audit = {"xform": xform.id_string}
audit_log(
Actions.FORM_XLS_DOWNLOADED, request.user, xform.user,
_("Downloaded XLS file for form '%(id_string)s'.") %
{"id_string": xform.id_string}, audit, request)
split_path = file_path.split(os.extsep)
extension = 'xls'
if len(split_path) > 1:
extension = split_path[len(split_path) - 1]
response = response_with_mimetype_and_name('vnd.ms-excel',
id_string,
show_date=False,
extension=extension,
file_path=file_path)
return response
else:
messages.add_message(
request, messages.WARNING,
_(u'No XLS file for your form '
u'<strong>%(id)s</strong>') % {'id': id_string})
return HttpResponseRedirect("/%s" % username)
def awc_pdf_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
permit_nums = request.GET.getlist('permit')
submission_type = request.GET.get('submissionType', '')
observations = request.GET.get('observations', None)
if observations:
observations = ["uuid:" + x for x in observations.strip().split(",")]
if not observations or len(observations) < 1 or len(observations) > 5:
return HttpResponseBadRequest("Provide between 1 and 5 observations")
if len(permit_nums) == 0:
return HttpResponseBadRequest("Must provide at least one permit")
pdf = generate_pdf(id_string, submission_type, observations,
user=owner, permit_nums=permit_nums) #TODO - Get full name. Also, observer or user?
response = HttpResponse(pdf, mimetype="application/pdf")
response['Content-Disposition'] = disposition_ext_and_date(
'-'.join(permit_nums), 'pdf')
response['Content-Length'] = len(pdf)
return response
def xls_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u"Not shared."))
query = request.GET.get("query")
force_xlsx = request.GET.get("xlsx") == "true"
xls_df_builder = XLSDataFrameBuilder(username, id_string, query)
excel_defs = {
"xls": {"suffix": ".xls", "mime_type": "vnd.ms-excel"},
"xlsx": {"suffix": ".xlsx", "mime_type": "vnd.openxmlformats"}, # TODO: check xlsx mime type
}
ext = "xls" if not force_xlsx else "xlsx"
if xls_df_builder.exceeds_xls_limits:
ext = "xlsx"
try:
temp_file = NamedTemporaryFile(suffix=excel_defs[ext]["suffix"])
xls_df_builder.export_to(temp_file.name)
if request.GET.get("raw"):
id_string = None
response = response_with_mimetype_and_name(excel_defs[ext]["mime_type"], id_string, extension=ext)
response.write(temp_file.read())
temp_file.seek(0, os.SEEK_END)
response["Content-Length"] = temp_file.tell()
temp_file.close()
return response
except NoRecordsFoundError:
return HttpResponse(_("No records found to export"))
def data_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
query = request.GET.get("query")
extension = export_type
# check if we should force xlsx
force_xlsx = request.GET.get('xls') != 'true'
if export_type == Export.XLS_EXPORT and force_xlsx:
extension = 'xlsx'
audit = {
"xform": xform.id_string,
"export_type": export_type
}
# check if we need to re-generate,
# we always re-generate if a filter is specified
if should_create_new_export(xform, export_type) or query:
try:
export = generate_export(
export_type, extension, username, id_string, None, query)
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created %(export_type)s export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
'export_type': export_type.upper()
}, audit, request)
except NoRecordsFoundError:
return HttpResponseNotFound(_("No records found to export"))
else:
export = newset_export_for(xform, export_type)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded %(export_type)s export on '%(id_string)s'.") %
{
'id_string': xform.id_string,
'export_type': export_type.upper()
}, audit, request)
if not export.filename:
# tends to happen when using newset_export_for.
return HttpResponseNotFound("File does not exist!")
# get extension from file_path, exporter could modify to
# xlsx if it exceeds limits
path, ext = os.path.splitext(export.filename)
ext = ext[1:]
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name(
Export.EXPORT_MIMES[ext], id_string, extension=ext,
file_path=export.filepath)
return response
def download_jsonform(request, username, id_string):
owner = User.objects.get(username=username)
xform = XForm.objects.get(user__username=username, id_string=id_string)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden('Not shared.')
response = response_with_mimetype_and_name('json', id_string,
show_date=False)
response.content = xform.json
return response
def export_progress(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
# find the export entry in the db
export_ids = request.GET.getlist('export_ids')
exports = Export.objects.filter(xform=xform, id__in=export_ids)
statuses = []
for export in exports:
status = {
'complete': False,
'url': None,
'filename': None,
'export_id': export.id
}
if export.status == Export.SUCCESSFUL:
status['url'] = reverse(export_download,
kwargs={
'username': owner.username,
'id_string': xform.id_string,
'export_type': export.export_type,
'filename': export.filename
})
status['filename'] = export.filename
if export.export_type == Export.GDOC_EXPORT and \
export.export_url is None:
redirect_url = reverse(export_progress,
kwargs={
'username': username,
'id_string': id_string,
'export_type': export_type
})
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
status['url'] = None
try:
url = google_export_xls(export.full_filepath,
xform.title,
token,
blob=True)
except Exception, e:
status['error'] = True
status['message'] = e.message
else:
export.export_url = url
export.save()
status['url'] = url
# mark as complete if it either failed or succeeded but NOT pending
if export.status == Export.SUCCESSFUL \
or export.status == Export.FAILED:
status['complete'] = True
statuses.append(status)
def data_view(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u"Not shared."))
context = RequestContext(request)
context.mongo_api_url = reverse(main.views.api, kwargs={"username": username, "id_string": id_string})
context.jsonform_url = reverse(download_jsonform, kwargs={"username": username, "id_string": id_string})
return render_to_response("data_view.html", context_instance=context)
def map_view(request, username, id_string, template='map.html'):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context = RequestContext(request)
context.content_user = owner
context.xform = xform
context.profile, created = UserProfile.objects.get_or_create(user=owner)
points = ParsedInstance.objects.values('lat', 'lng', 'instance').filter(
instance__user=owner,
instance__xform__id_string=id_string,
lat__isnull=False,
lng__isnull=False)
center = {
'lat': round_down_geopoint(average([p['lat'] for p in points])),
'lng': round_down_geopoint(average([p['lng'] for p in points])),
}
def round_down_point(p):
return {
'lat': round_down_geopoint(p['lat']),
'lng': round_down_geopoint(p['lng']),
'instance': p['instance']
}
context.center = json.dumps(center)
context.form_view = True
context.jsonform_url = reverse(download_jsonform,
kwargs={"username": username,
"id_string": id_string})
context.enketo_edit_url = reverse('edit_data',
kwargs={"username": username,
"id_string": id_string,
"data_id": 0})
context.enketo_add_url = reverse('enter_data',
kwargs={"username": username,
"id_string": id_string})
context.enketo_add_with_url = reverse('add_submission_with',
kwargs={"username": username,
"id_string": id_string})
context.mongo_api_url = reverse('mongo_view_api',
kwargs={"username": username,
"id_string": id_string})
context.delete_data_url = reverse('delete_data',
kwargs={"username": username,
"id_string": id_string})
context.mapbox_layer = MetaData.mapbox_layer_upload(xform)
audit = {
"xform": xform.id_string
}
audit_log(Actions.FORM_MAP_VIEWED, request.user, owner,
_("Requested map on '%(id_string)s'.")
% {'id_string': xform.id_string}, audit, request)
return render_to_response(template, context_instance=context)
def map_view(request, username, id_string, template='map.html'):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context = RequestContext(request)
context.content_user = owner
context.xform = xform
context.profile, created = UserProfile.objects.get_or_create(user=owner)
points = ParsedInstance.objects.values('lat', 'lng', 'instance').filter(
instance__user=owner,
instance__xform__id_string=id_string,
lat__isnull=False,
lng__isnull=False)
center = {
'lat': round_down_geopoint(average([p['lat'] for p in points])),
'lng': round_down_geopoint(average([p['lng'] for p in points])),
}
def round_down_point(p):
return {
'lat': round_down_geopoint(p['lat']),
'lng': round_down_geopoint(p['lng']),
'instance': p['instance']
}
context.center = json.dumps(center)
context.form_view = True
context.jsonform_url = reverse(download_jsonform,
kwargs={"username": username,
"id_string": id_string})
context.enketo_edit_url = reverse('edit_data',
kwargs={"username": username,
"id_string": id_string,
"data_id": 0})
context.enketo_add_url = reverse('enter_data',
kwargs={"username": username,
"id_string": id_string})
context.enketo_add_with_url = reverse('add_submission_with',
kwargs={"username": username,
"id_string": id_string})
context.mongo_api_url = reverse('mongo_view_api',
kwargs={"username": username,
"id_string": id_string})
context.delete_data_url = reverse('delete_data',
kwargs={"username": username,
"id_string": id_string})
context.mapbox_layer = MetaData.mapbox_layer_upload(xform)
audit = {
"xform": xform.id_string
}
audit_log(Actions.FORM_MAP_VIEWED, request.user, owner,
_("Requested map on '%(id_string)s'.")
% {'id_string': xform.id_string}, audit, request)
return render_to_response(template, context_instance=context)
def enketo_preview(request, username, id_string):
xform = get_object_or_404(XForm, user__username=username, id_string=id_string)
owner = xform.user
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden(_(u"Not shared."))
enekto_preview_url = "%(enketo_url)s?server=%(profile_url)s&id=%(id_string)s" % {
"enketo_url": settings.ENKETO_PREVIEW_URL,
"profile_url": request.build_absolute_uri(reverse(profile, kwargs={"username": owner.username})),
"id_string": xform.id_string,
}
return HttpResponseRedirect(enekto_preview_url)
def data_view(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
context = RequestContext(request)
context.mongo_api_url = reverse(main.views.api,\
kwargs={"username": username, "id_string": id_string})
context.jsonform_url = reverse(download_jsonform,\
kwargs={"username": username, "id_string":id_string})
return render_to_response("data_view.html", context_instance=context)
def kml_export(request, username, id_string):
# read the locations from the database
context = RequestContext(request)
context.message = "HELLO!!"
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u"Not shared."))
dd = DataDictionary.objects.get(id_string=id_string, user=owner)
pis = ParsedInstance.objects.filter(
instance__user=owner, instance__xform__id_string=id_string, lat__isnull=False, lng__isnull=False
)
data_for_template = []
labels = {}
def cached_get_labels(xpath):
if xpath in labels.keys():
return labels[xpath]
labels[xpath] = dd.get_label(xpath)
return labels[xpath]
for pi in pis:
# read the survey instances
data_for_display = pi.to_dict()
xpaths = data_for_display.keys()
xpaths.sort(cmp=pi.data_dictionary.get_xpath_cmp())
label_value_pairs = [
(cached_get_labels(xpath), data_for_display[xpath]) for xpath in xpaths if not xpath.startswith(u"_")
]
table_rows = []
for key, value in label_value_pairs:
table_rows.append("<tr><td>%s</td><td>%s</td></tr>" % (key, value))
img_urls = image_urls(pi.instance)
img_url = img_urls[0] if img_urls else ""
data_for_template.append(
{
"name": id_string,
"id": pi.id,
"lat": pi.lat,
"lng": pi.lng,
"image_urls": img_urls,
"table": '<table border="1"><a href="#"><img width="210" '
'class="thumbnail" src="%s" alt=""></a>%s'
"</table>" % (img_url, "".join(table_rows)),
}
)
context.data = data_for_template
response = render_to_response(
"survey.kml", context_instance=context, mimetype="application/vnd.google-earth.kml+xml"
)
response["Content-Disposition"] = disposition_ext_and_date(id_string, "kml")
return response
def enketo_preview(request, username, id_string):
xform = get_object_or_404(
XForm, user__username=username, id_string=id_string)
owner = xform.user
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
enekto_preview_url = "%(enketo_url)s?server=%(profile_url)s&id=%(id_string)s" % {
'enketo_url': ENKETO_PREVIEW_URL,
'profile_url': request.build_absolute_uri(reverse(profile, kwargs={'username': owner.username})),
'id_string': xform.id_string
}
return HttpResponseRedirect(enekto_preview_url)
def download_jsonform(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, user__username=username, id_string=id_string)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden("Not shared.")
response = response_with_mimetype_and_name("json", id_string, show_date=False)
if "callback" in request.GET and request.GET.get("callback") != "":
callback = request.GET.get("callback")
response.content = "%s(%s)" % (callback, xform.json)
else:
response.content = xform.json
return response
def export_progress(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
# find the export entry in the db
export_ids = request.GET.getlist('export_ids')
exports = Export.objects.filter(xform=xform, id__in=export_ids)
statuses = []
for export in exports:
status = {
'complete': False,
'url': None,
'filename': None,
'export_id': export.id
}
if export.status == Export.SUCCESSFUL:
status['url'] = reverse(export_download, kwargs={
'username': owner.username,
'id_string': xform.id_string,
'export_type': export.export_type,
'filename': export.filename
})
status['filename'] = export.filename
if export.export_type == Export.GDOC_EXPORT and \
export.export_url is None:
redirect_url = reverse(
export_progress,
kwargs={
'username': username, 'id_string': id_string,
'export_type': export_type})
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
status['url'] = None
try:
url = google_export_xls(
export.full_filepath, xform.title, token, blob=True)
except Exception, e:
status['error'] = True
status['message'] = e.message
else:
export.export_url = url
export.save()
status['url'] = url
# mark as complete if it either failed or succeeded but NOT pending
if export.status == Export.SUCCESSFUL \
or export.status == Export.FAILED:
status['complete'] = True
statuses.append(status)
def form_photos(request, username, id_string):
xform = get_object_or_404(XForm,
user__username=username, id_string=id_string)
owner = User.objects.get(username=username)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
context = RequestContext(request)
context.form_view = True
context.content_user = owner
context.xform = xform
context.images = image_urls_for_form(xform)
context.profile, created = UserProfile.objects.get_or_create(user=owner)
return render_to_response('form_photos.html', context_instance=context)
def create_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
query = request.POST.get("query")
force_xlsx = request.POST.get('xls') != 'true'
# export options
group_delimiter = request.POST.get("options[group_delimiter]", '/')
if group_delimiter not in ['.', '/']:
return HttpResponseBadRequest(
_("%s is not a valid delimiter" % group_delimiter))
# default is True, so when dont_.. is yes
# split_select_multiples becomes False
split_select_multiples = request.POST.get(
"options[dont_split_select_multiples]", "no") == "no"
options = {
'group_delimiter': group_delimiter,
'split_select_multiples': split_select_multiples
}
try:
create_async_export(xform, export_type, query, force_xlsx, options)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
else:
audit = {
"xform": xform.id_string,
"export_type": export_type
}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created %(export_type)s export on '%(id_string)s'.") %
{
'export_type': export_type.upper(),
'id_string': xform.id_string,
}, audit, request)
return HttpResponseRedirect(reverse(
export_list,
kwargs={
"username": username,
"id_string": id_string,
"export_type": export_type
})
)
def map_view(request, username, id_string, template='map.html'):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context = RequestContext(request)
context.content_user = owner
context.xform = xform
context.profile, created = UserProfile.objects.get_or_create(user=owner)
context.form_view = True
context.jsonform_url = reverse(download_jsonform,
kwargs={
"username": username,
"id_string": id_string
})
context.enketo_edit_url = reverse('edit_data',
kwargs={
"username": username,
"id_string": id_string,
"data_id": 0
})
context.enketo_add_url = reverse('enter_data',
kwargs={
"username": username,
"id_string": id_string
})
context.enketo_add_with_url = reverse('add_submission_with',
kwargs={
"username": username,
"id_string": id_string
})
context.mongo_api_url = reverse('mongo_view_api',
kwargs={
"username": username,
"id_string": id_string
})
context.delete_data_url = reverse('delete_data',
kwargs={
"username": username,
"id_string": id_string
})
context.mapbox_layer = MetaData.mapbox_layer_upload(xform)
audit = {"xform": xform.id_string}
audit_log(
Actions.FORM_MAP_VIEWED, request.user, owner,
_("Requested map on '%(id_string)s'.") %
{'id_string': xform.id_string}, audit, request)
return render_to_response(template, context_instance=context)
def create_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
query = request.POST.get("query")
force_xlsx = request.POST.get('xls') != 'true'
# export options
group_delimiter = request.POST.get("options[group_delimiter]", '/')
if group_delimiter not in ['.', '/']:
return HttpResponseBadRequest(
_("%s is not a valid delimiter" % group_delimiter))
# default is True, so when dont_.. is yes
# split_select_multiples becomes False
split_select_multiples = request.POST.get(
"options[dont_split_select_multiples]", "no") == "no"
options = {
'group_delimiter': group_delimiter,
'split_select_multiples': split_select_multiples
}
try:
create_async_export(xform, export_type, query, force_xlsx, options)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
else:
audit = {
"xform": xform.id_string,
"export_type": export_type
}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created %(export_type)s export on '%(id_string)s'.") %
{
'export_type': export_type.upper(),
'id_string': xform.id_string,
}, audit, request)
return HttpResponseRedirect(reverse(
export_list,
kwargs={
"username": username,
"id_string": id_string,
"export_type": export_type
})
)
def download_jsonform(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, user__username=username,
id_string=id_string)
helper_auth_helper(request)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden(_(u'Not shared.'))
response = response_with_mimetype_and_name('json', id_string,
show_date=False)
if 'callback' in request.GET and request.GET.get('callback') != '':
callback = request.GET.get('callback')
response.content = "%s(%s)" % (callback, xform.json)
else:
response.content = xform.json
return response
def download_xlsform(request, username, id_string):
xform = get_object_or_404(XForm, user__username=username, id_string=id_string)
owner = User.objects.get(username=username)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden("Not shared.")
file_path = xform.xls.name
default_storage = get_storage_class()()
if default_storage.exists(file_path):
response = response_with_mimetype_and_name(
"vnd.ms-excel", id_string, show_date=False, extension="xls", file_path=file_path
)
return response
else:
messages.add_message(request, messages.WARNING, "No XLS file for your form <strong>%s</strong>" % id_string)
return HttpResponseRedirect("/%s" % username)
def view_download_submission(request, username):
def extract_uuid(text):
text = text[text.find("@key="):-1].replace("@key=", "")
if text.startswith("uuid:"):
text = text.replace("uuid:", "")
return text
form_user = get_object_or_404(User, username=username)
profile, created = \
UserProfile.objects.get_or_create(user=form_user)
authenticator = HttpDigestAuthenticator()
if not authenticator.authenticate(request):
return authenticator.build_challenge_response()
context = RequestContext(request)
formId = request.GET.get('formId', None)
if not isinstance(formId, basestring):
return HttpResponseBadRequest()
id_string = formId[0:formId.find('[')]
form_id_parts = formId.split('/')
if form_id_parts.__len__() < 2:
return HttpResponseBadRequest()
uuid = extract_uuid(form_id_parts[1])
try:
instance = Instance.objects.filter(xform__id_string=id_string,
uuid=uuid,
user__username=username,
deleted_at=None)[0]
xform = instance.xform
if not has_permission(xform, form_user, request, xform.shared_data):
return HttpResponseForbidden('Not shared.')
submission_xml_root_node = instance.get_root_node()
submission_xml_root_node.setAttribute(
'instanceID', u'uuid:%s' % instance.uuid)
submission_xml_root_node.setAttribute(
'submissionDate', instance.date_created.isoformat()
)
context.submission_data = submission_xml_root_node.toxml()
context.media_files = Attachment.objects.filter(instance=instance)
context.host = request.build_absolute_uri().replace(
request.get_full_path(), '')
return render_to_response(
'downloadSubmission.xml', context_instance=context,
mimetype="text/xml; charset=utf-8")
except IndexError:
raise Http404
def yukon_xls_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
site_nums = request.GET.getlist('site')
if len(site_nums) != 1:
return HttpResponseBadRequest("Must provide a single site id")
xls = generate_yukon_xls(id_string, user=owner, site_nums=site_nums)
response = HttpResponse(xls, mimetype="application/vnd.ms-excel")
response['Content-Disposition'] = disposition_ext_and_date(
'-'.join(site_nums), 'xls')
return response
def download_jsonform(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm,
user__username=username,
id_string=id_string)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden('Not shared.')
response = response_with_mimetype_and_name('json',
id_string,
show_date=False)
if 'callback' in request.GET and request.GET.get('callback') != '':
callback = request.GET.get('callback')
response.content = "%s(%s)" % (callback, xform.json)
else:
response.content = xform.json
return response
def kml_export(request, username, id_string):
# read the locations from the database
context = RequestContext(request)
context.message="HELLO!!"
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
dd = DataDictionary.objects.get(id_string=id_string,
user=owner)
pis = ParsedInstance.objects.filter(instance__user=owner,
instance__xform__id_string=id_string, lat__isnull=False,
lng__isnull=False)
data_for_template = []
labels = {}
def cached_get_labels(xpath):
if xpath in labels.keys(): return labels[xpath]
labels[xpath] = dd.get_label(xpath)
return labels[xpath]
for pi in pis:
# read the survey instances
data_for_display = pi.to_dict()
xpaths = data_for_display.keys()
xpaths.sort(cmp=pi.data_dictionary.get_xpath_cmp())
label_value_pairs = [
(cached_get_labels(xpath),
data_for_display[xpath]) for xpath in xpaths
if not xpath.startswith(u"_")]
table_rows = []
for key, value in label_value_pairs:
table_rows.append('<tr><td>%s</td><td>%s</td></tr>' % (key, value))
img_urls = image_urls(pi.instance)
img_url = img_urls[0] if img_urls else ""
data_for_template.append({
'name':id_string,
'id': pi.id,
'lat': pi.lat,
'lng': pi.lng,
'image_urls': img_urls,
'table': '<table border="1"><a href="#"><img width="210" class="thumbnail" src="%s" alt=""></a>%s</table>' % (img_url,''.join(table_rows))})
context.data = data_for_template
response = render_to_response("survey.kml",
context_instance=context,
mimetype="application/vnd.google-earth.kml+xml")
response['Content-Disposition'] = disposition_ext_and_date(id_string, 'kml')
return response
def csv_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
valid, dd = dd_for_params(id_string, owner, request)
if not valid: return dd
writer = CsvWriter(dd, dd.get_data_for_excel(), dd.get_keys(),\
dd.get_variable_name)
file_path = writer.get_default_file_path()
writer.write_to_file(file_path)
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name('application/csv', id_string,
extension='csv',
file_path=file_path, use_local_filesystem=True)
return response
def view_download_submission(request, username):
def extract_uuid(text):
text = text[text.find("@key="):-1].replace("@key=", "")
if text.startswith("uuid:"):
text = text.replace("uuid:", "")
return text
form_user = get_object_or_404(User, username=username)
profile, created = \
UserProfile.objects.get_or_create(user=form_user)
authenticator = HttpDigestAuthenticator()
if not authenticator.authenticate(request):
return authenticator.build_challenge_response()
context = RequestContext(request)
formId = request.GET.get('formId', None)
if not isinstance(formId, basestring):
return HttpResponseBadRequest()
id_string = formId[0:formId.find('[')]
form_id_parts = formId.split('/')
if form_id_parts.__len__() < 2:
return HttpResponseBadRequest()
uuid = extract_uuid(form_id_parts[1])
try:
instance = Instance.objects.filter(xform__id_string=id_string,
uuid=uuid,
user__username=username,
deleted_at=None)[0]
xform = instance.xform
if not has_permission(xform, form_user, request, xform.shared_data):
return HttpResponseForbidden('Not shared.')
submission_xml_root_node = instance.get_root_node()
submission_xml_root_node.setAttribute('instanceID',
u'uuid:%s' % instance.uuid)
submission_xml_root_node.setAttribute(
'submissionDate', instance.date_created.isoformat())
context.submission_data = submission_xml_root_node.toxml()
context.media_files = Attachment.objects.filter(instance=instance)
context.host = request.build_absolute_uri().replace(
request.get_full_path(), '')
return render_to_response('downloadSubmission.xml',
context_instance=context,
mimetype="text/xml; charset=utf-8")
except IndexError:
raise Http404
def view_submission_list(request, username):
form_user = get_object_or_404(User, username=username)
profile, created = \
UserProfile.objects.get_or_create(user=form_user)
authenticator = HttpDigestAuthenticator()
if not authenticator.authenticate(request):
return authenticator.build_challenge_response()
context = RequestContext(request)
id_string = request.GET.get('formId', None)
xform = get_object_or_404(XForm,
id_string=id_string,
user__username=username)
if not has_permission(xform, form_user, request, xform.shared_data):
return HttpResponseForbidden('Not shared.')
num_entries = request.GET.get('numEntries', None)
cursor = request.GET.get('cursor', None)
instances = xform.surveys.filter(deleted_at=None).order_by('pk')
if cursor:
try:
cursor = int(cursor)
except ValueError:
pass
else:
instances = instances.filter(pk__gt=cursor)
if num_entries:
try:
num_entries = int(num_entries)
except ValueError:
pass
else:
instances = instances[:num_entries]
context.instances = instances
if instances.count():
last_instance = instances[instances.count() - 1]
context.resumptionCursor = last_instance.pk
elif instances.count() == 0 and cursor:
context.resumptionCursor = cursor
else:
context.resumptionCursor = 0
return render_to_response('submissionList.xml',
context_instance=context,
mimetype="text/xml; charset=utf-8")
def enter_data(request, username, id_string):
owner = User.objects.get(username=username)
xform = get_object_or_404(XForm,
user__username=username,
id_string=id_string)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
if not hasattr(settings, 'TOUCHFORMS_URL'):
return HttpResponseRedirect(
reverse('main.views.show',
kwargs={
'username': username,
'id_string': id_string
}))
url = settings.TOUCHFORMS_URL
register_openers()
response = None
with tempfile.TemporaryFile() as tmp:
tmp.write(xform.xml.encode('utf-8'))
tmp.seek(0)
values = {'file': tmp, 'format': 'json', 'uuid': xform.uuid}
data, headers = multipart_encode(values)
headers['User-Agent'] = 'formhub'
req = urllib2.Request(url, data, headers)
try:
response = urllib2.urlopen(req)
response = json.loads(response.read())
context = RequestContext(request)
owner = User.objects.get(username=username)
context.profile, created = UserProfile.objects.get_or_create(
user=owner)
context.xform = xform
context.content_user = owner
context.form_view = True
context.touchforms = response['url']
return render_to_response("form_entry.html",
context_instance=context)
#return HttpResponseRedirect(response['url'])
except urllib2.URLError:
pass # this will happen if we could not connect to touchforms
return HttpResponseRedirect(
reverse('main.views.show',
kwargs={
'username': username,
'id_string': id_string
}))
def frp_xls_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
permit_nums = request.GET.getlist('permit')
biol_date = request.GET.get('biologistContactDate', '')
if len(permit_nums) != 1:
return HttpResponseBadRequest("Must provide a single permit")
pdf = generate_frp_xls(id_string, biol_date,
user=owner, permit_nums=permit_nums)
response = HttpResponse(pdf, mimetype="application/vnd.ms-excel")
response['Content-Disposition'] = disposition_ext_and_date(
'-'.join(permit_nums), 'xls')
return response
def data_view(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
context = RequestContext(request)
context.owner = owner
context.xform = xform
audit = {
"xform": xform.id_string,
}
audit_log(
Actions.FORM_DATA_VIEWED, request.user, owner,
_("Requested data view for '%(id_string)s'.") % {
'id_string': xform.id_string,
}, audit, request)
return render_to_response("data_view.html", context_instance=context)
def xls_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
valid, dd = dd_for_params(id_string, owner, request)
if not valid: return dd
ddw = XlsWriter()
ddw.set_data_dictionary(dd)
temp_file = ddw.save_workbook_to_file()
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name('vnd.ms-excel', id_string,
extension='xls')
response.write(temp_file.getvalue())
temp_file.seek(0, os.SEEK_END)
response['Content-Length'] = temp_file.tell()
temp_file.close()
return response
def google_xls_export(request, username, id_string):
token = None
if request.user.is_authenticated():
try:
ts = TokenStorageModel.objects.get(id=request.user)
except TokenStorageModel.DoesNotExist:
pass
else:
token = ts.token
elif request.session.get('access_token'):
token = request.session.get('access_token')
if token is None:
request.session["google_redirect_url"] = reverse(google_xls_export,
kwargs={
'username':
username,
'id_string':
id_string
})
return HttpResponseRedirect(redirect_uri)
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
valid, dd = dd_for_params(id_string, owner, request)
if not valid:
return dd
ddw = XlsWriter()
tmp = NamedTemporaryFile(delete=False)
ddw.set_file(tmp)
ddw.set_data_dictionary(dd)
temp_file = ddw.save_workbook_to_file()
temp_file.close()
url = google_export_xls(tmp.name, xform.title, token, blob=True)
os.unlink(tmp.name)
audit = {"xform": xform.id_string, "export_type": "google"}
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created Google Docs export on '%(id_string)s'.") % {
'id_string': xform.id_string,
}, audit, request)
return HttpResponseRedirect(url)
def download_xlsform(request, username, id_string):
xform = get_object_or_404(XForm,
user__username=username,
id_string=id_string)
owner = User.objects.get(username=username)
if not has_permission(xform, owner, request, xform.shared):
return HttpResponseForbidden('Not shared.')
file_path = xform.xls.name
default_storage = get_storage_class()()
if default_storage.exists(file_path):
response = response_with_mimetype_and_name('vnd.ms-excel',
id_string,
show_date=False,
extension='xls',
file_path=file_path)
return response
else:
messages.add_message(
request, messages.WARNING,
'No XLS file for your form <strong>%s</strong>' % id_string)
return HttpResponseRedirect("/%s" % username)
def google_xls_export(request, username, id_string):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden('Not shared.')
valid, dd = dd_for_params(id_string, owner, request)
if not valid: return dd
ddw = XlsWriter()
tmp = NamedTemporaryFile(delete=False)
ddw.set_file(tmp)
ddw.set_data_dictionary(dd)
temp_file = ddw.save_workbook_to_file()
temp_file.close()
import gdata
import gdata.gauth
import gdata.docs
import gdata.data
import gdata.docs.client
import gdata.docs.data
from main.google_export import token, refresh_access_token, redirect_uri
from main.models import TokenStorageModel
try:
ts = TokenStorageModel.objects.get(id=request.user)
except TokenStorageModel.DoesNotExist:
return HttpResponseRedirect(redirect_uri)
else:
stored_token = gdata.gauth.token_from_blob(ts.token)
if stored_token.refresh_token is not None and\
stored_token.access_token is not None:
token.refresh_token = stored_token.refresh_token
working_token = refresh_access_token(token, request.user)
docs_client = gdata.docs.client.DocsClient(source=token.user_agent)
docs_client = working_token.authorize(docs_client)
xls_doc = gdata.docs.data.Resource(
type='spreadsheet', title=xform.title)
media = gdata.data.MediaSource()
media.SetFileHandle(tmp.name, 'application/vnd.ms-excel')
xls_doc = docs_client.CreateResource(xls_doc, media=media)
os.unlink(tmp.name)
return HttpResponseRedirect('https://docs.google.com')
def export_download(request, username, id_string, export_type, filename):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
# find the export entry in the db
export = get_object_or_404(Export, xform=xform, filename=filename)
if export_type == Export.GDOC_EXPORT and export.export_url is not None:
return HttpResponseRedirect(export.export_url)
ext, mime_type = export_def_from_filename(export.filename)
audit = {
"xform": xform.id_string,
"export_type": export.export_type
}
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded %(export_type)s export '%(filename)s' "
"on '%(id_string)s'.") %
{
'export_type': export.export_type.upper(),
'filename': export.filename,
'id_string': xform.id_string,
}, audit, request)
if request.GET.get('raw'):
id_string = None
default_storage = get_storage_class()()
if not isinstance(default_storage, FileSystemStorage):
return HttpResponseRedirect(default_storage.url(export.filepath))
basename = os.path.splitext(export.filename)[0]
response = response_with_mimetype_and_name(
mime_type, name=basename, extension=ext,
file_path=export.filepath, show_date=False)
return response
def data_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username=username)
xform = get_object_or_404(XForm, id_string=id_string, user=owner)
helper_auth_helper(request)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
query = request.GET.get("query")
extension = export_type
# check if we should force xlsx
force_xlsx = request.GET.get('xls') != 'true'
if export_type == Export.XLS_EXPORT and force_xlsx:
extension = 'xlsx'
elif export_type == Export.CSV_ZIP_EXPORT:
extension = 'zip'
audit = {"xform": xform.id_string, "export_type": export_type}
# check if we need to re-generate,
# we always re-generate if a filter is specified
if should_create_new_export(xform, export_type) or query or\
'start' in request.GET or 'end' in request.GET:
format_date_for_mongo = lambda x, datetime: datetime.strptime(
x, '%y_%m_%d_%H_%M_%S').strftime('%Y-%m-%dT%H:%M:%S')
# check for start and end params
if 'start' in request.GET or 'end' in request.GET:
if not query:
query = '{}'
query = json.loads(query)
query[SUBMISSION_TIME] = {}
try:
if request.GET.get('start'):
query[SUBMISSION_TIME]['$gte'] = format_date_for_mongo(
request.GET['start'], datetime)
if request.GET.get('end'):
query[SUBMISSION_TIME]['$lte'] = format_date_for_mongo(
request.GET['end'], datetime)
except ValueError:
return HttpResponseBadRequest(
_("Dates must be in the format YY_MM_DD_hh_mm_ss"))
else:
query = json.dumps(query)
try:
export = generate_export(export_type, extension, username,
id_string, None, query)
audit_log(
Actions.EXPORT_CREATED, request.user, owner,
_("Created %(export_type)s export on '%(id_string)s'.") % {
'id_string': xform.id_string,
'export_type': export_type.upper()
}, audit, request)
except NoRecordsFoundError:
return HttpResponseNotFound(_("No records found to export"))
else:
export = newset_export_for(xform, export_type)
# log download as well
audit_log(
Actions.EXPORT_DOWNLOADED, request.user, owner,
_("Downloaded %(export_type)s export on '%(id_string)s'.") % {
'id_string': xform.id_string,
'export_type': export_type.upper()
}, audit, request)
if not export.filename:
# tends to happen when using newset_export_for.
return HttpResponseNotFound("File does not exist!")
# get extension from file_path, exporter could modify to
# xlsx if it exceeds limits
path, ext = os.path.splitext(export.filename)
ext = ext[1:]
if request.GET.get('raw'):
id_string = None
response = response_with_mimetype_and_name(Export.EXPORT_MIMES[ext],
id_string,
extension=ext,
file_path=export.filepath)
return response