def create_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
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"
binary_select_multiples = getattr(settings, 'BINARY_SELECT_MULTIPLES',
False)
# external export option
meta = request.POST.get("meta")
options = {
'group_delimiter': group_delimiter,
'split_select_multiples': split_select_multiples,
'binary_select_multiples': binary_select_multiples,
'meta': meta.replace(",", "") if meta else None
}
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 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__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'meta': export_meta,
'token': export_token,
}
if should_create_new_export(xform, export_type):
try:
create_async_export(
xform, export_type, query=None, force_xlsx=True,
options=options)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
metadata = MetaData.objects.filter(xform=xform,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
data = {
'username': owner.username,
'xform': xform,
'export_type': export_type,
'export_type_name': Export.EXPORT_TYPE_DICT[export_type],
'exports': Export.objects.filter(
xform=xform, export_type=export_type).order_by('-created_on'),
'metas': metadata
}
return render(request, 'export_list.html', data)
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__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'meta': export_meta,
'token': export_token,
}
if should_create_new_export(xform, export_type):
try:
create_async_export(
xform, export_type, query=None, force_xlsx=True,
options=options)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
metadata = MetaData.objects.filter(xform=xform,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
data = {
'username': owner.username,
'xform': xform,
'export_type': export_type,
'export_type_name': Export.EXPORT_TYPE_DICT[export_type],
'exports': Export.objects.filter(
xform=xform, export_type=export_type).order_by('-created_on'),
'metas': metadata
}
return render(request, 'export_list.html', data)
def export_list(request, username, id_string, export_type, is_project=0, id=0, site_id=0, version="0"):
site_id = int(site_id)
if export_type == Export.GDOC_EXPORT:
return HttpResponseForbidden(_(u'Not shared.'))
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if export_type == Export.EXTERNAL_EXPORT:
return HttpResponseForbidden(_(u'Not shared.'))
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'meta': export_meta,
'token': export_token,
}
metadata = MetaData.objects.filter(xform=xform,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
data = {
'username': xform.user.username,
'xform': xform,
'export_type': export_type,
'export_type_name': Export.EXPORT_TYPE_DICT[export_type],
'exports': Export.objects.filter(
xform=xform, export_type=export_type, fsxf=id, site=site_id, version=version).order_by('-created_on'),
'metas': metadata,
'is_project': is_project,
'id': id,
'version': version,
}
data['site_id'] = site_id
return render(request, 'export_list.html', data)
def create_export(request,
username,
id_string,
export_type,
is_project=None,
id=None,
site_id=0,
version="0",
sync_to_gsuit="0"):
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
if is_project == 1 or is_project == '1':
query = {"fs_project_uuid": str(id)}
else:
fsxf = FieldSightXF.objects.get(pk=id)
if fsxf.site:
query = {"fs_uuid": str(id)}
else:
query = {"fs_project_uuid": str(id), "fs_site": site_id}
force_xlsx = True
if version not in ["0", 0]:
query["__version__"] = version
deleted_at_query = {
"$or": [{
"_deleted_at": {
"$exists": False
}
}, {
"_deleted_at": None
}]
}
# join existing query with deleted_at_query on an $and
query = {"$and": [query, deleted_at_query]}
print("query at excel generation", query)
# 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"
binary_select_multiples = getattr(settings, 'BINARY_SELECT_MULTIPLES',
False)
# external export option
meta = request.POST.get("meta")
options = {
'group_delimiter': group_delimiter,
'split_select_multiples': split_select_multiples,
'binary_select_multiples': binary_select_multiples,
'meta': meta.replace(",", "") if meta else None
}
try:
sync_to_gsuit = True if sync_to_gsuit in ["1", 1] else False
create_async_export(xform, export_type, query, force_xlsx, options,
is_project, id, site_id, version, sync_to_gsuit)
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)
kwargs = {
"username": username,
"id_string": id_string,
"export_type": export_type,
"is_project": is_project,
"id": id,
"version": version
}
kwargs['site_id'] = site_id
return HttpResponseRedirect(reverse(export_list, kwargs=kwargs))
def create_export(request, username, id_string, export_type):
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
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"
binary_select_multiples = getattr(settings, 'BINARY_SELECT_MULTIPLES',
False)
# external export option
meta = request.POST.get("meta")
options = {
'group_delimiter': group_delimiter,
'split_select_multiples': split_select_multiples,
'binary_select_multiples': binary_select_multiples,
'meta': meta.replace(",", "") if meta else None
}
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 export_list(request, username, id_string, export_type):
credential = None
if export_type not in Export.EXPORT_TYPE_DICT:
return HttpResponseBadRequest(
_(u'Export type "%s" is not supported.' % export_type))
if export_type == Export.GOOGLE_SHEETS_EXPORT:
# Retrieve google creds or redirect to google authorization page
credential = _get_google_credential(request)
if isinstance(credential, HttpResponseRedirect):
return credential
owner = get_object_or_404(User, username__iexact=username)
xform = get_form({'user': owner, 'id_string__iexact': id_string})
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'group_delimiter': DEFAULT_GROUP_DELIMITER,
'remove_group_name': False,
'split_select_multiples': True,
'binary_select_multiples': False,
'meta': export_meta,
'token': export_token,
'google_credentials': credential
}
if should_create_new_export(xform, export_type, options):
try:
create_async_export(xform,
export_type,
query=None,
force_xlsx=True,
options=options)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
metadata = MetaData.objects.filter(object_id=xform.id,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
data = {
'username':
owner.username,
'xform':
xform,
'export_type':
export_type,
'export_type_name':
Export.EXPORT_TYPE_DICT[export_type],
'exports':
Export.objects.filter(xform=xform,
export_type=export_type).order_by('-created_on'),
'metas':
metadata
}
return render(request, 'export_list.html', data)
def custom_project_window(request, username, id_string, **kwargs):
"""
Replaces the default kobo project window.
Creates a one page solution with one page view.
"""
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
#if not has_permission(xform, owner, request):
if not check_form_permissions(xform, str(request.user), 'can_view'):
return HttpResponseForbidden(_(u'Not shared.'))
user_list = get_own_and_partner_orgs_usermodule_users(request)
username_list = [
str(custom_user.user.username) for custom_user in user_list
]
username_list.append(str(request.user.username))
# data grid view part
data = {
'owner': owner,
'xform': xform,
'form_map_url':
'/' + owner.username + '/forms/' + xform.id_string + '/map',
'user_list': username_list
}
# start: export part
export_type = 'xls'
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
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'meta': export_meta,
'token': export_token,
}
export_type_zip = 'zip'
if export_type_zip == Export.GDOC_EXPORT:
redirect_url = reverse(export_list,
kwargs={
'username': username,
'id_string': id_string,
'export_type': export_type_zip
})
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
if export_type_zip == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
#code is commented to stop auto export generation
# if should_create_new_export(xform, export_type):
# try:
# create_async_export(
# xform, export_type, query=None, force_xlsx=True,
# options=options)
# except Export.ExportTypeError:
# return HttpResponseBadRequest(
# _("%s is not a valid export type" % export_type))
metadata = MetaData.objects.filter(xform=xform,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
#tab_selection = '#' + request.GET.get('tab_selection','grid')
tab_selection = '#' + request.GET.get('tab_selection', 'data_table')
# print tab_selection
data.update({
'username':
owner.username,
'xform':
xform,
'export_type':
export_type,
'export_type_zip':
export_type_zip,
'export_type_name':
Export.EXPORT_TYPE_DICT[export_type],
'export_type_name_zip':
Export.EXPORT_TYPE_DICT[export_type_zip],
'exports':
Export.objects.filter(
Q(xform=xform, export_type='xls')
| Q(xform=xform, export_type='csv')).order_by('-created_on'),
'exports_zip':
Export.objects.filter(xform=xform,
export_type='zip').order_by('-created_on'),
'metas':
metadata,
'tab_selection':
tab_selection,
})
# end: export part
# start: image gallery part
# instances = Instance.objects.filter(xform=xform).values('id')
# instances_list = [instance['id'] for instance in instances]
# attachments = Attachment.objects.filter(instance__in=instances_list,mimetype__icontains='image').values('media_file')
# image_list = []
# for i in attachments:
# image = {}
# image['url'] = request.build_absolute_uri('/media/'+i['media_file'])
# image['title'] = i['media_file'][i['media_file'].rfind('/')+1:]
# image_list.append(image)
# data.update({
# 'image_list': image_list,
# })
# end: image gallery part
return render(request, "usermodule/custom_project_window.html", data)
def export_list(request, username, id_string, export_type):
"""
Export list view.
"""
credential = None
if export_type not in Export.EXPORT_TYPE_DICT:
return HttpResponseBadRequest(
_(u'Export type "%s" is not supported.' % export_type))
if export_type == Export.GOOGLE_SHEETS_EXPORT:
# Retrieve google creds or redirect to google authorization page
credential = _get_google_credential(request)
if isinstance(credential, HttpResponseRedirect):
return credential
owner = get_object_or_404(User, username__iexact=username)
xform = get_form({'user': owner, 'id_string__iexact': id_string})
if not has_permission(xform, owner, request):
return HttpResponseForbidden(_(u'Not shared.'))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'group_delimiter': DEFAULT_GROUP_DELIMITER,
'remove_group_name': False,
'split_select_multiples': True,
'binary_select_multiples': False,
'meta': export_meta,
'token': export_token,
'google_credentials': credential
}
if should_create_new_export(xform, export_type, options):
try:
create_async_export(
xform,
export_type,
query=None,
force_xlsx=True,
options=options)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
metadata_qs = MetaData.objects.filter(object_id=xform.id,
data_type="external_export")\
.values('id', 'data_value')
for metadata in metadata_qs:
metadata['data_value'] = metadata.get('data_value').split('|')[0]
data = {
'username': owner.username,
'xform': xform,
'export_type': export_type,
'export_type_name': Export.EXPORT_TYPE_DICT[export_type],
'exports': Export.objects.filter(
xform=xform, export_type=export_type).order_by('-created_on'),
'metas': metadata_qs
} # yapf: disable
return render(request, 'export_list.html', data)
def export_list(request, username, id_string, export_type, is_project=0, id=0, site_id=0, version="0"):
site_id = int(site_id)
if export_type == Export.GDOC_EXPORT:
return HttpResponseForbidden(_(u'Not shared.'))
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if export_type == Export.EXTERNAL_EXPORT:
return HttpResponseForbidden(_(u'Not shared.'))
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'meta': export_meta,
'token': export_token,
}
if should_create_new_export(xform, export_type, id, site_id, version):
if is_project == 1 or is_project == '1':
query = {"fs_project_uuid": str(id)}
else:
fsxf = FieldSightXF.objects.get(pk=id)
if fsxf.site:
query = {"fs_uuid": str(id)}
else:
query = {"fs_project_uuid": str(id), "fs_site": site_id}
force_xlsx = True
if version not in ["0", 0]:
query["__version__"] = version
deleted_at_query = {
"$or": [{"_deleted_at": {"$exists": False}},
{"_deleted_at": None}]}
# join existing query with deleted_at_query on an $and
query = {"$and": [query, deleted_at_query]}
print("query at excel generation", query)
try:
create_async_export(xform, export_type, query,
force_xlsx, options, is_project, id, site_id, version)
except Export.ExportTypeError:
return HttpResponseBadRequest(
_("%s is not a valid export type" % export_type))
metadata = MetaData.objects.filter(xform=xform,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
data = {
'username': xform.user.username,
'xform': xform,
'export_type': export_type,
'export_type_name': Export.EXPORT_TYPE_DICT[export_type],
'exports': Export.objects.filter(
xform=xform, export_type=export_type, fsxf=id, site=site_id, version=version).order_by('-created_on'),
'metas': metadata,
'is_project': is_project,
'id': id,
'version': version,
}
data['site_id'] = site_id
return render(request, 'export_list.html', data)
def custom_project_window(request, username, id_string, **kwargs):
"""
Replaces the default kobo project window.
Creates a one page solution with one page view.
"""
owner = get_object_or_404(User, username__iexact=username)
xform = get_object_or_404(XForm, id_string__exact=id_string, user=owner)
if not check_form_permissions(xform, str(request.user), 'can_view'):
return HttpResponseForbidden(_(u'Not shared.'))
user_list = get_own_and_partner_orgs_usermodule_users(request)
username_list = [
str(custom_user.user.username) for custom_user in user_list
]
username_list.append(str(request.user.username))
# data grid view part
data = {
'owner': owner,
'xform': xform,
'form_map_url':
'/' + owner.username + '/forms/' + xform.id_string + '/map',
'user_list': username_list
}
#form multilanguage handle part
languages = ['English']
query = "select id FROM logger_instance WHERE xform_id = (select id from logger_xform where id_string = '" + id_string + "') limit 1"
print "##########testing##########"
instance_id = __db_fetch_single_value(query)
if instance_id:
query = "SELECT * from public.get_instance_extracted_temp(" + str(
instance_id) + ")"
form_data = __db_fetch_values_dict(query)
omitFieldsLang = [
'formhub/uuid', 'meta/instanceID', '_xform_id_string', 'username'
]
first_field = ''
for f in form_data:
if f['_field_name'] not in omitFieldsLang:
first_field = f['_q_title']
#print "data"
#print first_field
break
if first_field.startswith('{'):
languages = sjson.loads(first_field).keys()
print languages
# start: export part
export_type = 'xls'
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
default_fields_query = "select default_fields from public.export_default_parent where id_string = '" + id_string + "'"
cursor = connection.cursor()
cursor.execute(default_fields_query)
default_fields_data = cursor.fetchone()
dictlist = []
if default_fields_data is not None:
sorted_keys = sorted(list(default_fields_data[0].keys()))
#print type(sorted_keys)
for value in sorted_keys:
dictlist.append(str(default_fields_data[0][value]))
if export_type == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
# Get meta and token
export_token = request.GET.get('token')
export_meta = request.GET.get('meta')
options = {
'meta': export_meta,
'token': export_token,
}
export_type_zip = 'zip'
if export_type_zip == Export.GDOC_EXPORT:
redirect_url = reverse(export_list,
kwargs={
'username': username,
'id_string': id_string,
'export_type': export_type_zip
})
token = _get_google_token(request, redirect_url)
if isinstance(token, HttpResponse):
return token
if export_type_zip == Export.EXTERNAL_EXPORT:
# check for template before trying to generate a report
if not MetaData.external_export(xform=xform):
return HttpResponseForbidden(_(u'No XLS Template set.'))
#code is commented to stop auto export generation
# if should_create_new_export(xform, export_type):
# try:
# create_async_export(
# xform, export_type, query=None, force_xlsx=True,
# options=options)
# except Export.ExportTypeError:
# return HttpResponseBadRequest(
# _("%s is not a valid export type" % export_type))
metadata = MetaData.objects.filter(xform=xform,
data_type="external_export")\
.values('id', 'data_value')
for m in metadata:
m['data_value'] = m.get('data_value').split('|')[0]
#tab_selection = '#' + request.GET.get('tab_selection','grid')
tab_selection = '#' + request.GET.get('tab_selection', 'data_table')
# print tab_selection
data.update({
'username':
owner.username,
'xform':
xform,
'export_type':
export_type,
'export_type_zip':
export_type_zip,
'export_type_name':
Export.EXPORT_TYPE_DICT[export_type],
'export_type_name_zip':
Export.EXPORT_TYPE_DICT[export_type_zip],
'exports':
Export.objects.filter(
Q(xform=xform, export_type='xls')
| Q(xform=xform, export_type='csv')).order_by('-created_on'),
'exports_zip':
Export.objects.filter(xform=xform,
export_type='zip').order_by('-created_on'),
'metas':
metadata,
'tab_selection':
tab_selection,
'default_fields_data':
dictlist,
'language':
languages,
})
# end: export part
# start: image gallery part
# instances = Instance.objects.filter(xform=xform).values('id')
# instances_list = [instance['id'] for instance in instances]
# attachments = Attachment.objects.filter(instance__in=instances_list,mimetype__icontains='image').values('media_file')
# image_list = []
# for i in attachments:
# image = {}
# image['url'] = request.build_absolute_uri('/media/'+i['media_file'])
# image['title'] = i['media_file'][i['media_file'].rfind('/')+1:]
# image_list.append(image)
# data.update({
# 'image_list': image_list,
# })
# end: image gallery part
return render(request, "usermodule/custom_project_window.html", data)
