def redirect_report_on_date(request,start_day,end_day,namespace,slug,output=None):
"""Utility that allows for a redirect of a report based upon the date range to the appropriate filter"""
report=reportengine.get_report(namespace,slug)
params = dict(request.REQUEST)
if report.date_field:
# TODO this only works with model fields, needs to be more generic
dates = {"%s__gte"%report.date_field:start_day,"%s__lt"%report.date_field:end_day}
params.update(dates)
if output:
return HttpResponseRedirect("%s?%s"%(reverse("reports-view-format",args=[namespace,slug,output]),urlencode(params)))
return HttpResponseRedirect("%s?%s"%(reverse("reports-view",args=[namespace,slug]),urlencode(params)))
def test_report_register(self):
"""
Tests registering a report, and verifies report is now accessible
"""
r=BasicTestReport()
reportengine.register(r)
assert(reportengine.get_report("testing","test") == r)
found=False
for rep in reportengine.all_reports():
if rep[0] == (r.namespace,r.slug):
assert(rep[1] == r)
found=True
assert(found)
def test_report_register(self):
"""
Tests registering a report, and verifies report is now accessible
"""
r = BasicTestReport()
reportengine.register(r)
assert (reportengine.get_report("testing", "test") == r)
found = False
for rep in reportengine.all_reports():
if rep[0] == (r.namespace, r.slug):
assert (rep[1] == r)
found = True
assert (found)
def handle(self, *args, **kwargs):
if not kwargs['namespace'] or not kwargs['report']:
raise CommandError('--namespace and --report are required')
## Try to open the file path if specified, default to sys.stdout if it wasn't
if kwargs['file']:
try:
output = file(kwargs['file'], 'w')
except Exception:
raise CommandError('Could not open file path for writing')
else:
output = sys.stdout
reportengine.autodiscover() ## Populate the reportengine registry
try:
report = reportengine.get_report(kwargs['namespace'], kwargs['report'])()
except Exception, err:
raise CommandError('Could not find report for (%(namespace)s, %(report)s)' % kwargs)
def handle(self, *args, **kwargs):
if not kwargs['namespace'] or not kwargs['report']:
raise CommandError('--namespace and --report are required')
## Try to open the file path if specified, default to sys.stdout if it wasn't
if kwargs['file']:
try:
output = file(kwargs['file'], 'w')
except Exception:
raise CommandError('Could not open file path for writing')
else:
output = sys.stdout
reportengine.autodiscover() ## Populate the reportengine registry
try:
report = reportengine.get_report(kwargs['namespace'], kwargs['report'])()
except Exception, err:
raise CommandError('Could not find report for (%(namespace)s, %(report)s)' % kwargs)
def redirect_report_on_date(request,
start_day,
end_day,
namespace,
slug,
output=None):
"""Utility that allows for a redirect of a report based upon the date range to the appropriate filter"""
report = reportengine.get_report(namespace, slug)
params = dict(request.REQUEST)
if report.date_field:
# TODO this only works with model fields, needs to be more generic
dates = {
"%s__gte" % report.date_field: start_day,
"%s__lt" % report.date_field: end_day
}
params.update(dates)
if output:
return HttpResponseRedirect(
"%s?%s" %
(reverse("reports-view-format", args=[namespace, slug, output
]), urlencode(params)))
return HttpResponseRedirect(
"%s?%s" %
(reverse("reports-view", args=[namespace, slug]), urlencode(params)))
def get_report_class(self):
return reportengine.get_report(self.kwargs['namespace'],
self.kwargs['slug'])
def get_report(self):
return reportengine.get_report(self.namespace, self.slug)()
def get_report(self):
"""
Gets a report object, based on this ReportRequest's slug and namespace.
:return: A subclass of reportengine.Report
"""
return reportengine.get_report(self.namespace, self.slug)()
def get_report_class(self):
namespace = self.kwargs.get('namespace', self.request.POST.get('namespace'))
slug = self.kwargs.get('slug', self.request.POST.get('slug'))
return reportengine.get_report(namespace, slug)
def view_report(request, namespace, slug, output=None):
report = reportengine.get_report(namespace,slug)()
params=dict(request.REQUEST)
order_by=params.pop(ORDER_VAR,None)
page,per_page=0,report.per_page
try:
page=int(params.pop(PAGE_VAR,0))
except ValueError:
pass # ignore bogus page/per_page
# Filters are served as forms from the report
filter_form=report.get_filter_form(request)
if filter_form.fields:
if filter_form.is_valid():
filters=filter_form.cleaned_data
else:
# If invalid filters, blank out filters so form error can propagate up
filters={}
else:
# If no filter form fields are present, we just allow params to go through
# CONSIDER making this allowance explicit? e.g. report.allow_unspecified_filters
if report.allow_unspecified_filters:
filters=dict(request.REQUEST)
else:
filters={}
# Remove blank filters
for k in filters.keys():
if filters[k] == '':
del filters[k]
# Merge filters with default mask
mask = report.get_default_mask()
mask.update(filters)
# pull the rows and aggregates
rows,aggregates = report.get_rows(mask,order_by=order_by)
# Determine output format, as it can squash paging if it wants
outputformat=None
if output:
for of in report.output_formats:
if of.slug == output:
outputformat=of
if not outputformat:
outputformat = report.output_formats[0]
# Fill out the paginator if we have specified a page length
paginator=None
cl=None
if per_page and not outputformat.no_paging:
paginator=Paginator(rows,per_page)
p=paginator.page(page+1)
rows=p.object_list
# HACK: fill up a fake ChangeList object to use the admin paginator
class MiniChangeList:
def __init__(self,paginator,page,per_page,params):
self.paginator=paginator
self.page_num=page
self.show_all=report.can_show_all
self.can_show_all=False
self.multi_page=True
self.params=params
def get_query_string(self,new_params=None,remove=None):
# Do I need to deal with new_params/remove?
if remove != None:
for k in remove:
del self.params[k]
if new_params != None:
self.params.update(new_params)
return "?%s"%urlencode(self.params)
cl_params=order_by and dict(params,order_by=order_by) or params
cl=MiniChangeList(paginator,page,per_page,cl_params)
data = {'report': report,
'title':report.verbose_name,
'rows':rows,
'filter_form':filter_form,
"aggregates":aggregates,
"paginator":paginator,
"cl":cl,
"page":page,
"urlparams":urlencode(request.REQUEST)}
return outputformat.get_response(data,request)
def get_report(self):
report = reportengine.get_report(self.namespace, self.slug)()
# in case labels list depends on report parameters
report.process_params(self.params)
return report
def view_report(request, namespace, slug, output=None):
report = reportengine.get_report(namespace, slug)()
params = dict(request.REQUEST)
order_by = params.pop(ORDER_VAR, None)
page, per_page = 0, report.per_page
try:
page = int(params.pop(PAGE_VAR, 0))
except ValueError:
pass # ignore bogus page/per_page
# Filters are served as forms from the report
filter_form = report.get_filter_form(request)
if filter_form.fields:
if filter_form.is_valid():
filters = filter_form.cleaned_data
else:
# If invalid filters, blank out filters so form error can propagate up
filters = {}
else:
# If no filter form fields are present, we just allow params to go through
# CONSIDER making this allowance explicit? e.g. report.allow_unspecified_filters
if report.allow_unspecified_filters:
filters = dict(request.REQUEST)
else:
filters = {}
# Remove blank filters
for k in filters.keys():
if filters[k] == '':
del filters[k]
# Merge filters with default mask
mask = report.get_default_mask()
# get_custom_make alters the filters passed in removing
# them from the filters if they are a custom mask
custom_mask, filters = report.get_custom_mask(filters)
mask.update(custom_mask)
mask.update(filters)
# pull the rows and aggregates
rows, aggregates = report.get_rows(mask, order_by=order_by)
# Determine output format, as it can squash paging if it wants
outputformat = None
if output:
for of in report.output_formats:
if of.slug == output:
outputformat = of
if not outputformat:
outputformat = report.output_formats[0]
# Fill out the paginator if we have specified a page length
paginator = None
cl = None
if per_page and not outputformat.no_paging:
paginator = Paginator(rows, per_page)
p = paginator.page(page + 1)
rows = p.object_list
# HACK: fill up a fake ChangeList object to use the admin paginator
class MiniChangeList:
def __init__(self, paginator, page, per_page, params):
self.paginator = paginator
self.page_num = page
self.show_all = report.can_show_all
self.can_show_all = False
self.multi_page = True
self.params = params
def get_query_string(self, new_params=None, remove=None):
# Do I need to deal with new_params/remove?
if remove != None:
for k in remove:
del self.params[k]
if new_params != None:
self.params.update(new_params)
return "?%s" % urlencode(self.params)
cl_params = order_by and dict(params, order_by=order_by) or params
cl = MiniChangeList(paginator, page, per_page, cl_params)
data = {
'report': report,
'title': report.verbose_name,
'rows': rows,
'filter_form': filter_form,
"aggregates": aggregates,
"paginator": paginator,
"cl": cl,
"page": page,
"urlparams": urlencode(request.REQUEST)
}
return outputformat.get_response(data, request)
def get_report_class(self):
return reportengine.get_report(self.kwargs['namespace'], self.kwargs['slug'])
def handle(self, *args, **kwargs):
if not kwargs['namespace'] or not kwargs['report']:
raise CommandError('--namespace and --report are required')
## Try to open the file path if specified, default to sys.stdout if it wasn't
if kwargs['file']:
try:
output = file(kwargs['file'], 'w')
except Exception:
raise CommandError('Could not open file path for writing')
else:
output = sys.stdout
reportengine.autodiscover() ## Populate the reportengine registry
try:
report = reportengine.get_report(kwargs['namespace'], kwargs['report'])()
except Exception as err:
raise CommandError('Could not find report for (%(namespace)s, %(report)s)' % kwargs)
## Parse our filters
request = dict(parse_qsl(kwargs['filter']))
filter_form = report.get_filter_form(request)
if filter_form.fields:
if filter_form.is_valid():
filters = filter_form.cleaned_data
else:
filters = {}
else:
if report.allow_unspecified_filters:
filters = request
else:
filters = {}
# Remove blank filters
for k in filters.keys():
if filters[k] == '':
del filters[k]
## Update the mask and run the report!
mask = report.get_default_mask()
mask.update(filters)
rows, aggregates = report.get_rows(mask, order_by=kwargs['order_by'])
## Get our output format, setting a default if one wasn't set or isn't valid for this report
outputformat = None
if output:
for format in report.output_formats:
if format.slug == kwargs['format']:
outputformat = format
if not outputformat:
## By default, [0] is AdminOutputFormat, so grab the last one instead
outputformat = report.output_formats[-1]
context = {
'report': report,
'title': report.verbose_name,
'rows': rows,
'filter_form': filter_form,
'aggregates': aggregates,
'paginator': None,
'cl': None,
'page': 0,
'urlparams': kwargs['filter']
}
outputformat.generate_output(context, output)
output.close()
