label="Group by",

        choices=choices,

        required=False,

    )

def model_fields_form_factory(model):

    ''' Creates a form for specifying fields from a model to display. '''

    fields = model._meta.get_fields()

    choices = []

    for field in fields:

        if hasattr(field, "verbose_name"):

            choices.append((field.name, field.verbose_name))

    class ModelFieldsForm(forms.Form):

        fields = forms.MultipleChoiceField(

            choices=choices,

            required=False,

        )

    return ModelFieldsForm

        form_type (Optional[forms.Form]):

            A form class that can make this report display things. If not

            supplied, no form will be displayed.

    '''

    # Create & return view

    def _report(view):

        report_view = ReportView(view, title, form_type)

        report_view = user_passes_test(views._staff_only)(report_view)

        report_view = wraps(view)(report_view)

        # Add this report to the list of reports.

        _all_report_views.append(report_view)

        return report_view

    return _report

class ReportView(object):

    def __init__(self, inner_view, title, form_type):

        # Consolidate form_type so it has content type and section

        self.inner_view = inner_view

        self.title = title

        self.form_type = form_type

    def __call__(self, request, *a, **k):

        data = ReportViewRequestData(self, request, *a, **k)

        return self.render(data)

    def get_form(self, request):

        # Create a form instance

        if self.form_type is not None:

            form = self.form_type(request.GET)

            # Pre-validate it

            form.is_valid()

        else:

            form = None

        return form

    @classmethod

    def wrap_reports(cls, reports, content_type):

        reports = [

            _ReportTemplateWrapper(content_type, report)

            for report in reports

        ]

        return reports

    def render(self, data):

        renderers = {

            "text/csv": self._render_as_csv,

            "text/html": self._render_as_html,

        }

        render = renderers[data.content_type]

        return render(data)

    def _render_as_html(self, data):

        ctx = {

            "title": self.title,

            "form": data.form,

            "reports": data.reports,

        }

        return render(data.request, "registrasion/report.html", ctx)

    def _render_as_csv(self, data):

        report = data.reports[data.section]

        # Create the HttpResponse object with the appropriate CSV header.

        response = HttpResponse(content_type='text/csv')

        writer = csv.writer(response)

        encode = lambda i: i.encode("utf8") if isinstance(i, unicode) else i

        writer.writerow(list(encode(i) for i in report.headings()))

        for row in report.rows():

            writer.writerow(list(encode(i) for i in row))

        return response

class ReportViewRequestData(object):

    def __init__(self, report_view, request, *a, **k):

        self.report_view = report_view

        self.request = request

        # Calculate other data

        self.form = report_view.get_form(request)

        # Reports come from calling the inner view

        reports = report_view.inner_view(request, self.form, *a, **k)

        # Normalise to a list

        if isinstance(reports, Report):

            reports = [reports]

        # Wrap them in appropriate format

        reports = ReportView.wrap_reports(reports, self.content_type)

        self.reports = reports

def get_all_reports():

    ''' Returns all the views that have been registered with @report '''

    return list(_all_report_views)

    Returns:

        [models.commerce.Invoice, ...]: All of the current user's invoices. '''

    return commerce.Invoice.objects.filter(user=context.request.user)

@register.assignment_tag(takes_context=True)

def items_pending(context):

    ''' Gets all of the items that the user from this context has reserved.'''

    return ItemController(context.request.user).items_pending()

@register.assignment_tag(takes_context=True)

def items_purchased(context, category=None):

    ''' Returns the items purchased for this user. '''

    return ItemController(context.request.user).items_purchased(

        category=category

    )

@register.assignment_tag(takes_context=True)

def report_as_csv(context, section):

    querystring = urlencode(query)

    return context.request.path + "?" + querystring