def select( request,
redirect_field_name = REDIRECT_FIELD_NAME,
domain_select_template = 'domain/select.html' ):
domains_for_user = Domain.active_for_user(request.user)
if len(domains_for_user) == 0:
vals = dict( error_msg = "You are not a member of any existing domains - please contact your system administrator",
show_homepage_link = False )
return render_to_response(request, 'error.html', vals)
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == 'POST': # If the form has been submitted...
form = DomainSelectionForm(domain_list=domains_for_user,
data=request.POST) # A form bound to the POST data
if form.is_valid():
# We've just checked the submitted data against a freshly-retrieved set of domains
# associated with the user. It's safe to set the domain in the sesssion (and we'll
# check again on views validated with the domain-checking decorator)
form.save(request) # Needs request because it saves domain in session
# Weak attempt to give user a good UX - make sure redirect_to isn't garbage.
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = reverse('homepage')
return HttpResponseRedirect(redirect_to) # Redirect after POST
else:
# An unbound form
form = DomainSelectionForm( domain_list=domains_for_user )
vals = dict( next = redirect_to,
form = form )
return render_to_response(request, domain_select_template, vals)
def post(req, template_name):
xform_body = req.POST["xform"]
hq_validation = True if "hq-validate" in req.POST else False
try:
xformvalidator.validate_xml(xform_body, do_hq_validation=hq_validation)
return render_to_response(req, template_name, {"success": True,
"message": "Your form was successfully validated!",
"xform": xform_body
})
except Exception, e:
return render_to_response(req, template_name, {"success": False,
"message": "Validation Fail! %s" % e,
"xform": xform_body
})
def reregister_xform(request, domain_name, template='register_and_list_xforms.html'):
# registers an xform without having a user context, for
# server-generated submissions
context = {}
if request.method == 'POST':
# must add_schema to storage provide first since forms are dependent upon elements
try:
metadata = request.META
domain = Domain.objects.get(name=domain_name)
type = metadata["HTTP_SCHEMA_TYPE"]
schema = request.raw_post_data
xformmanager = XFormManager()
formdefmodel = xformmanager.add_schema_manually(schema, type, domain)
except IOError, e:
logging.error("xformmanager.manager: " + unicode(e) )
context['errors'] = "Could not convert xform to schema. Please verify correct xform format."
context['upload_form'] = RegisterXForm()
context['registered_forms'] = FormDefModel.objects.all().filter(domain__name=domain_name)
return render_to_response(request, template, context)
except Exception, e:
logging.error(e)
logging.error("Unable to write raw post data<br/>")
logging.error("Unable to write raw post data: Exception: " + unicode(sys.exc_info()[0]) + "<br/>")
logging.error("Unable to write raw post data: Traceback: " + unicode(sys.exc_info()[1]))
type, value, tb = sys.exc_info()
logging.error(unicode(type.__name__), ":", unicode(value))
logging.error("error parsing attachments: Traceback: " + '\n'.join(traceback.format_tb(tb)))
logging.error("Transaction rolled back")
context['errors'] = "Unable to write raw post data" + unicode(sys.exc_info()[0]) + unicode(sys.exc_info()[1])
transaction.rollback()
def delete_data(request, formdef_id, template='confirm_multiple_delete.html'):
context = {}
form = get_object_or_404(FormDefModel, pk=formdef_id)
if request.method == "POST":
if 'instance' in request.POST:
request.session['xform_data'] = []
metadata = []
for i in request.POST.getlist('instance'):
# user has selected items and clicked 'delete'
# redirect to confirmation
if 'checked_'+ i in request.POST:
meta = Metadata.objects.get(formdefmodel=form, raw_data=int(i))
metadata.append(meta)
request.session['xform_data'].append(int(i))
context['xform_data'] = metadata
elif 'confirm_delete' in request.POST:
# user has confirmed deletion. Proceed.
xformmanager = XFormManager()
for id in request.session['xform_data']:
xformmanager.remove_data(formdef_id, id)
logging.debug("Instances %s of schema %s were deleted.", \
(unicode(request.session['xform_data']), formdef_id))
request.session['xform_data'] = None
return HttpResponseRedirect( reverse("xformmanager.views.data", \
args=[formdef_id]) )
else:
request.session['xform_data'] = None
context['form_name'] = form.form_display_name
context['formdef_id'] = formdef_id
return render_to_response(request, template, context)
def xmlns_group_popup(request):
"""Popup (compact) view a group of forms for a particular xmlns.
Used in modal dialogs."""
xmlns = request.GET["xmlns"]
group = FormDefModel.get_group_for_namespace(request.user.selected_domain, xmlns)
return render_to_response(request, "xformmanager/xmlns_group_popup.html",
{"group": group})
def post(req, template_name="xformmanager/readable_form_creator.html"):
xform_body = req.POST["xform"]
try:
result, errors, has_error = readable_form(xform_body)
return render_to_response(req, "xformmanager/readable_form_creator.html",
{"success": True,
"message": "Your form was successfully validated!",
"xform": xform_body,
"readable_form": result
})
except Exception, e:
return render_to_response(req, "xformmanager/readable_form_creator.html",
{"success": False,
"message": "Failure to generate readable xform! %s" % e,
"xform": xform_body
})
def edit_program(request, program_id):
program = get_object_or_404(Program.objects.filter(domain=request.user.selected_domain), pk=program_id)
if request.method == "POST":
original_ids = set([user.id for user in program.get_users()])
form = ProgramForm(request.POST, instance=program)
if form.is_valid():
edit_program = form.save(commit=False)
edit_program.domain = request.user.selected_domain
edit_program.save()
if "users" in request.POST:
updated_ids = set([int(id) for id in request.POST.getlist("users")])
else:
updated_ids = set([])
to_remove = original_ids.difference(updated_ids)
to_add = updated_ids.difference(original_ids)
for user_id in to_add:
edit_program.add_user(User.objects.get(id=user_id))
for user_id in to_remove:
edit_program.remove_user(User.objects.get(id=user_id))
return HttpResponseRedirect(reverse('list_programs'))
else:
form = ProgramForm(instance=program)
users = User.objects.filter(domain_membership__domain = request.user.selected_domain)
def add_selected(user, program):
if user in program.get_users(): user.selected = True
return user
users = map(add_selected, users, (program,) * users.count())
return render_to_response(request, "program/program_add.html",
{"form": form, "users": users})
def annotations(request, attachment_id, allow_add=True):
# TODO: error checking
attach = Attachment.objects.get(id=attachment_id)
annotes = attach.annotations.all()
return render_to_response(request, "receiver/partials/annotations.html", {"attachment": attach,
"annotations": annotes,
"allow_add": allow_add})
def show_submits(request, template_name="receiver/show_submits.html"):
'''View submissions for this domain.'''
context = {}
slogs = Submission.objects.filter(domain=request.user.selected_domain).order_by('-submit_time')
context['submissions'] = paginate(request, slogs)
return render_to_response(request, template_name, context)
def user_list_paging(request, queryset, sort_vars=None):
# django_table checks to see if sort field is allowable - won't raise an error if the field isn't present
# (unlike filtering of a raw queryset)
order_by=request.GET.get('sort', 'username')
user_table = UserTable(queryset, order_by)
paginator = Paginator(user_table.rows, 20, orphans=2)
# Code taken from Django dev docs explaining pagination
# Make sure page request is an int. If not, deliver first page.
try:
page = int(request.GET.get('page', '1'))
except ValueError:
page = 1
# If page request (9999) is out of range, deliver last page of results.
try:
users = paginator.page(page)
except (EmptyPage, InvalidPage):
users = paginator.page(paginator.num_pages)
sort_index = -1
counter = 0
for name in user_table.columns.names():
if order_by == name or order_by == "-%s" % name:
sort_index = counter
break
counter += 1
return render_to_response(request, 'domain/user_list.html',
{ 'columns': user_table.columns, 'rows':users, 'sort':order_by, 'sort_vars':sort_vars,
"sort_index": sort_index})
def single_submission(request, submission_id, template_name="receiver/single_submission.html"):
context = {}
slog = Submission.objects.all().filter(id=submission_id)
context['submission'] = slog[0]
rawstring = str(slog[0].raw_header)
# In order to display the raw header information, we need to
# escape the python object brackets in the output
rawstring = rawstring.replace(': <',': "<')
rawstring = rawstring.replace('>,','>",')
rawstring = rawstring.replace('>}','>"}')
processed_header = eval(rawstring)
get_original = False
for item in request.GET.items():
if item[0] == 'get_original':
get_original = True
if get_original:
response = HttpResponse(mimetype='text/plain')
fin = open(slog[0].raw_post ,'r')
txt = fin.read()
fin.close()
response.write(txt)
return response
attachments = Attachment.objects.all().filter(submission=slog[0])
context ['processed_header'] = processed_header
context['attachments'] = attachments
return render_to_response(request, template_name, context)
def edit_form_data_group_columns(req, group_id):
"""Edit the individual columns of a form data group"""
group = get_object_or_404(FormDataGroup, id=group_id)
if req.method == 'POST':
for key, value in req.POST.items():
if key.startswith("checked_"):
to_delete = key.replace("checked_", "")
column = group.columns.get(name=to_delete)
column.delete()
elif key.startswith("select_"):
truncated_name = key.replace("select_", "")
form_id, column = truncated_name.split("_", 1)
form = FormDefModel.objects.get(id=form_id)
try:
column_obj = group.columns.get(name=column)
except FormDataColumn.DoesNotExist:
# this likely just got deleted above or came from
# an out of date request. For now just quietly
# ignore it.
continue
if value == NOT_SET:
# the only time we have to do anything here is if
# it was previously set.
try:
old_field = column_obj.fields.get(form=form)
# we found something, better get rid of it
column_obj.fields.remove(old_field)
column_obj.save()
except FormDataPointer.DoesNotExist:
# we weren't expecting anything so nothing to do
pass
else:
# we code these as select_<formid>_<column_name>
new_column = value
new_field = FormDataPointer.objects.get(form=form,
column_name=new_column)
try:
old_field = column_obj.fields.get(form=form)
if old_field == new_field:
# we didn't change anything, leave it
pass
else:
# remove the old field from the column
# and add the new one
column_obj.fields.remove(old_field)
column_obj.fields.add(new_field)
column_obj.save()
except FormDataPointer.DoesNotExist:
# there was no previous mapping for this. Just
# add the new one
column_obj.fields.add(new_field)
column_obj.save()
else:
pass
# take them back to the viewing page
return HttpResponseRedirect(reverse('xformmanager.views.form_data_group',
kwargs={"group_id": group.id }))
return render_to_response(req, "xformmanager/edit_form_data_group_columns.html",
{"group": group, "editing": True })
def formdesigner(request, template_name="openrosa/FormDesigner.html"):
return render_to_response(request,
template_name,
{},
context_instance=RequestContext(request)
)
def delete_form_data_group(req, group_id):
group = get_object_or_404(FormDataGroup, id=group_id)
if req.method == 'POST':
group.delete()
return HttpResponseRedirect(reverse('xformmanager.views.dashboard'))
return render_to_response(req, "xformmanager/delete_form_data_group.html",
{"group": group, "editing": False })
def xmlns_group(request):
"""View a group of forms for a particular xmlns."""
xmlns = request.GET["xmlns"]
group = FormDefModel.get_group_for_namespace(request.user.selected_domain, xmlns)
data_groups = FormDataGroup.objects.filter(forms__in=group.forms).distinct()
return render_to_response(request, "xformmanager/xmlns_group.html",
{"group": group,
"data_groups": data_groups
})
def registration_confirm(request, guid=None):
# Did we get a guid?
vals = {'show_homepage_link': 1 }
if guid is None:
vals['error_msg'] = 'No domain activation key submitted - nothing to activate'
return render_to_response(request, 'error.html', vals)
# Does guid exist in the system?
reqs = RegistrationRequest.objects.filter(activation_guid=guid)
if len(reqs) != 1:
vals['error_msg'] = 'Submitted link is invalid - no domain with the activation key "' + guid + '" was requested'
return render_to_response(request, 'error.html', vals)
# Has guid already been confirmed?
req = reqs[0]
if req.domain.is_active:
assert(req.confirm_time is not None and req.confirm_ip is not None)
vals['error_msg'] = 'Domain "' + req.domain.name + '" has already been activated - no further validation required'
return render_to_response(request, 'error.html', vals)
# Set confirm time and IP; activate domain and new user who is in the
try:
req.confirm_time = datetime.datetime.now()
req.confirm_ip = request.META['REMOTE_ADDR']
req.domain.is_active = True
req.domain.save()
req.new_user.is_active = True
req.new_user.save()
req.save()
except:
transaction.rollback()
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:
transaction.commit()
vals = {'domain_name':req.domain.name,
'username':req.new_user.username }
return render_to_response(request, 'domain/registration_confirmed.html', vals)
def password_change(req):
user_to_edit = User.objects.get(id=req.user.id)
if req.method == 'POST':
password_form = AdminPasswordChangeForm(user_to_edit, req.POST)
if password_form.is_valid():
password_form.save()
return HttpResponseRedirect('/')
else:
password_form = AdminPasswordChangeForm(user_to_edit)
template_name="password_change.html"
return render_to_response(req, template_name, {"form" : password_form})
def registration_resend_confirm_email(request):
if request.method == 'POST': # If the form has been submitted...
form = ResendConfirmEmailForm(request.POST) # A form bound to the POST data
if form.is_valid():
dom_req = form.retrieved_domain.registrationrequest
try:
_send_domain_registration_email( dom_req.new_user.email, dom_req.domain.name, dom_req.activation_guid, dom_req.new_user.username )
except:
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(email=dom_req.new_user.email)
return render_to_response(request, 'domain/registration_received.html', vals)
else:
form = ResendConfirmEmailForm()
vals = dict(form=form)
return render_to_response(request, 'domain/registration_resend_confirm_email.html', vals)
def delete_submission(request, submission_id=None, template='receiver/confirm_delete.html'):
context = {}
submission = get_object_or_404(Submission, pk=submission_id)
if request.method == "POST":
if request.POST["confirm_delete"]: # user has confirmed deletion.
submission.delete()
logging.debug("Submission %s deleted ", submission_id)
return HttpResponseRedirect(reverse('show_submits'))
context['object'] = submission
context['type'] = 'Submission'
return render_to_response(request, template, context)
def show_dupes(request, submission_id, template_name="receiver/show_dupes.html"):
'''View duplicates of this submission.'''
context = {}
submit = get_object_or_404(Submission, id=submission_id)
if submit.checksum is None or len(submit.checksum) == 0:
# this error will go away as soon as we update all submissions
# to have corresponding checksums
context['errors'] = "No checksum found. Cannot identify duplicates."
else:
slogs = Submission.objects.filter(checksum=submit.checksum).order_by('-submit_time')
context['submissions'] = paginate(request, slogs)
return render_to_response(request, template_name, context)
def remove_xform(request, form_id=None, template='confirm_delete.html'):
context = {}
form = get_object_or_404(FormDefModel, pk=form_id)
if request.method == "POST":
if request.POST["confirm_delete"]: # The user has already confirmed the deletion.
xformmanager = XFormManager()
xformmanager.remove_schema(form_id)
logging.debug("Schema %s deleted ", form_id)
#self.message_user(request, _('The %(name)s "%(obj)s" was deleted successfully.') % {'name': force_unicode(opts.verbose_name), 'obj': force_unicode(obj_display)})
return HttpResponseRedirect(reverse('xformmanager.views.dashboard'))
context['form_name'] = form.form_display_name
return render_to_response(request, template, context)
def registration_request(request, kind=None):
# Logic to decide whehter or not we're creating a new user to go with the new domain, or reusing the
# logged-in user's account. First we normalize kind, so it's a recognized value, and then we decide
# what to do based in part on whether the user is logged in.
if not (kind=='new_user' or kind=='existing_user'):
kind = None
if request.user.is_authenticated():
if kind is None:
# Redirect to a page which lets user choose whether or not to create a new account
vals = {}
return render_to_response(request, 'domain/registration_reuse_account_p.html', vals)
else: # not authenticated
kind = 'new_user'
assert(kind == 'existing_user' or kind == 'new_user')
if request.method == 'POST': # If the form has been submitted...
form = RegistrationRequestForm(kind, request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Make sure we haven't violated the max reqs per day. This is defined as "same calendar date, in UTC,"
# NOT as "trailing 24 hours"
now = datetime.datetime.utcnow()
reqs_today = RegistrationRequest.objects.filter(request_time__gte = now.date()).count()
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)
try:
dom_req = _create_new_domain_request( request, kind, form, now )
if kind == 'new_user': # existing_users are automatically activated; no confirmation email
_send_domain_registration_email( dom_req.new_user.email, dom_req.domain.name,
dom_req.activation_guid, dom_req.new_user.username )
except:
transaction.rollback()
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:
transaction.commit()
# Only gets here if the database-insert try block's else clause executed
if kind == 'existing_user':
vals = {'domain_name':dom_req.domain.name, 'username':request.user.username}
return render_to_response(request, 'domain/registration_confirmed.html', vals)
else: # new_user
vals = dict(email=form.cleaned_data['email'])
return render_to_response(request, 'domain/registration_received.html', vals)
else:
form = RegistrationRequestForm(kind) # An unbound form
vals = dict(form = form, kind=kind)
return render_to_response(request, 'domain/registration_form.html', vals)
def admin_own_account_update(request):
if request.method == 'POST': # If the form has been submitted...
form = UpdateSelfForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
user_from_db = User.objects.get(id = request.user.id)
table_vals = [ {'property':form.base_fields[x].label,
'old_val':user_from_db.__dict__[x],
'new_val':form.cleaned_data[x]} for x in form.cleaned_data.keys() ]
table = UpdateSelfTable(table_vals, order_by=('Property',))
user_from_db.__dict__.update(form.cleaned_data)
user_from_db.save()
return render_to_response(request, 'admin_own_account_update_done.html', dict(table=table))
else:
initial_vals = {}
for x in UpdateSelfForm.base_fields.keys():
initial_vals[x] = request.user.__dict__[x]
form = UpdateSelfForm(initial=initial_vals) # An unbound form - can render, but it can't validate
vals = dict(form=form)
return render_to_response(request, 'admin_own_account_update_form.html', vals)
########################################################################################################
def single_xform(request, formdef_id, template_name="single_xform.html"):
context = {}
show_schema = False
for item in request.GET.items():
if item[0] == 'show_schema':
show_schema = True
xform = FormDefModel.objects.get(id=formdef_id)
if show_schema:
response = HttpResponse(mimetype='text/xml')
fin = open(xform.xsd_file_location ,'r')
txt = fin.read()
fin.close()
response.write(txt)
return response
else:
context['xform_item'] = xform
return render_to_response(request, template_name, context)
def create_form_data_group_from_xmlns(req):
"""Create a form data group from a set of forms matching an xmlns"""
xmlns = req.GET["xmlns"]
try:
FormDataGroup.objects.get(name=xmlns)
# if this works, we already think we have a group. Perhaps we should
# ask for confirmation and allow them to recreate, but for now we'll
# just claim this is an error. This can be significantly UI-improved.
error_message = "Sorry, there's already a data group created for that xmlns."
return render_to_response(req, "500.html", {"error_message" : error_message})
except FormDataGroup.DoesNotExist:
# this is the correct workflow.
forms = FormDefModel.objects.filter(domain=req.user.selected_domain,
target_namespace=xmlns)
group = FormDataGroup.from_forms(forms, req.user.selected_domain)
return HttpResponseRedirect(reverse('xformmanager.views.form_data_group',
kwargs={"group_id": group.id }))
def edit_form_data_group(req, group_id):
"""Edit a model-defined group of forms"""
group = get_object_or_404(FormDataGroup, id=group_id)
form_validation = None
if req.method == "POST":
group_form = FormDataGroupForm(req.POST, instance=group)
if group_form.is_valid():
if "formdefs" in req.POST:
form_ids = req.POST.getlist("formdefs")
if not form_ids:
form_validation = "You must choose at least one form!"
else:
group = group_form.save()
set_forms = [FormDefModel.objects.get(id=form_id) for form_id in form_ids]
previous_forms = group.forms.all()
new_forms = [form for form in set_forms if form not in previous_forms]
deleted_forms = [form for form in previous_forms if form not in set_forms]
# don't forget to do all the default column updates as well.
for form in new_forms:
group.add_form(form)
for form in deleted_forms:
group.remove_form(form)
if new_forms or deleted_forms:
# finally, if anything changed update the sql view
group.update_view()
# and take them back to the viewing page
return HttpResponseRedirect(reverse('xformmanager.views.form_data_group',
kwargs={"group_id": group.id }))
else:
form_validation = "You must choose at least one form!"
else:
group_form = FormDataGroupForm(instance=group)
all_forms = FormDefModel.objects.filter(domain=req.user.selected_domain)\
.order_by("target_namespace", "version")
selected_forms = group.forms.all()
unused_forms = [form for form in all_forms if form not in selected_forms]
return render_to_response(req, "xformmanager/edit_form_data_group.html",
{"group_form": group_form,
"group": group,
"selected_forms": selected_forms,
"all_forms": unused_forms,
"form_validation": form_validation })
def single_instance(request, formdef_id, instance_id, template_name="single_instance.html"):
'''
View data for a single xform instance submission.
'''
xform = FormDefModel.objects.get(id=formdef_id)
# for now, the formdef version/uiversion is equivalent to
# the instance version/uiversion
data = [('XMLNS',xform.target_namespace), ('Version',xform.version),
('uiVersion',xform.uiversion)]
attach = xform.get_attachment(instance_id)
row = xform.get_row(instance_id)
fields = xform.get_display_columns()
# make them a list of tuples of field, value pairs for easy iteration
data = data + zip(fields, row)
return render_to_response(request, template_name, {"form" : xform,
"id": instance_id,
"data": data,
"attachment": attach })
def new_form_data_group(req):
"""Create a new model-defined group of forms"""
form_validation = None
if req.method == "POST":
form = FormDataGroupForm(req.POST)
if form.is_valid():
if "formdefs" in req.POST:
form_ids = req.POST.getlist("formdefs")
if not form_ids:
form_validation = "You must choose at least one form!"
else:
new_group = form.save(commit=False)
new_group.domain = req.user.selected_domain
# TODO: better handling of the name attribute.
new_group.name = get_unique_value(FormDataGroup.objects, "name", new_group.display_name)
forms = [FormDefModel.objects.get(id=form_id) for form_id in form_ids]
new_group.save()
new_group.forms = forms
new_group.save()
# don't forget to do all the default column updates as well.
for form in forms:
new_group.add_form_columns(form)
# finally update the sql view
new_group.update_view()
# when done, take them to the edit page for further tweaking
return HttpResponseRedirect(reverse('xformmanager.views.edit_form_data_group',
kwargs={"group_id": new_group.id }))
else:
form_validation = "You must choose at least one form!"
else:
form = FormDataGroupForm()
all_forms = FormDefModel.objects.filter(domain=req.user.selected_domain)\
.order_by("target_namespace", "version")
return render_to_response(req, "xformmanager/edit_form_data_group.html",
{"group_form": form,
"all_forms": all_forms,
"selected_forms": [],
"form_validation": form_validation })
def add_program(request):
"""Add a program to a domain"""
if request.method == "POST":
form = ProgramForm(request.POST)
if form.is_valid():
new_program = form.save(commit=False)
new_program.domain = request.user.selected_domain
new_program.save()
if "users" in request.POST:
user_ids = request.POST.getlist("users")
else:
user_ids = set([])
for user_id in user_ids:
new_program.add_user(User.objects.get(id=user_id))
return HttpResponseRedirect(reverse('list_programs'))
else:
form = ProgramForm()
users = User.objects.filter(domain_membership__domain = request.user.selected_domain)
return render_to_response(request, "program/program_add.html",
{"form": form, "users": users})
def form_data_group(req, group_id):
group = get_object_or_404(FormDataGroup, id=group_id)
items, sort_column, sort_descending, filters =\
get_table_display_properties(req,default_sort_column = None,
default_sort_descending = False)
cursor = group.get_data(sort_column, sort_descending)
columns = get_column_names(cursor)
if sort_column:
sort_index = columns.index(sort_column)
else:
sort_index = -1
data = paginate(req, cursor.fetchall())
extra_params = "&".join(['%s=%s' % (key, value)\
for key, value in req.GET.items()\
if key != "page"])
return render_to_response(req, "xformmanager/form_data_group.html",
{"group": group, "columns": columns,
"data": data, "sort_column": sort_column,
"sort_descending": sort_descending,
"sort_index": sort_index,
"extra_params": extra_params,
"editing": False })
