def overview_stats(request):
"""
Allow admins to generate fancy statistic graphs for different models
"""
statistics_providers = []
models_map = {}
for model in models.get_models():
try:
getattr(model.objects, 'filter_overview')
statistics_providers.append((str(model.__name__).lower(), model.statistics_name))
models_map[str(model.__name__).lower()] = model
except AttributeError:
pass
if not statistics_providers:
"""
Something went FUBAR - Misago ships with some stats providers out of box
If those providers cant be found, this means Misago filesystem is corrupted
"""
return request.theme.render_to_response('overview/stats/not_available.html',
context_instance=RequestContext(request));
message = None
if request.method == 'POST':
form = GenerateStatisticsForm(request.POST, provider_choices=statistics_providers, request=request)
if form.is_valid():
date_start = form.cleaned_data['date_start']
date_end = form.cleaned_data['date_end']
if date_start > date_end:
# Reverse dates if start is after end
date_temp = date_end
date_end = date_start
date_start = date_temp
# Assert that dates are correct
if date_end == date_start:
message = BasicMessage(_('Start and end date are same'), type='error')
elif check_dates(date_start, date_end, form.cleaned_data['stats_precision']):
message = check_dates(date_start, date_end, form.cleaned_data['stats_precision'])
else:
request.messages.set_flash(BasicMessage(_('Statistical report has been created.')), 'success', 'admin_stats')
return redirect(reverse('admin_overview_graph', kwargs={
'model': form.cleaned_data['provider_model'],
'date_start': date_start.strftime('%Y-%m-%d'),
'date_end': date_end.strftime('%Y-%m-%d'),
'precision': form.cleaned_data['stats_precision']
}))
else:
message = Message(request, form.non_field_errors()[0])
message.type = 'error'
else:
form = GenerateStatisticsForm(provider_choices=statistics_providers, request=request)
return request.theme.render_to_response('overview/stats/form.html', {
'form': FormLayout(form),
'message': message,
}, context_instance=RequestContext(request));
def get_and_validate_target(self, request, target):
try:
model = self.admin.model.objects.select_related().get(pk=target)
self.get_target(request, model)
return model
except self.admin.model.DoesNotExist:
request.messages.set_flash(BasicMessage(self.notfound_message), 'error', self.admin.id)
except ValueError as e:
request.messages.set_flash(BasicMessage(e.args[0]), 'error', self.admin.id)
return None
def settings_search(request):
settings_groups = Group.objects.all().order_by('key')
message = None
found_settings = []
try:
if request.method == 'POST' and request.csrf.request_secure(request):
form = SearchForm(request.POST, request=request)
if form.is_valid():
# Start search
search_strings = SearchQuery(form.cleaned_data['search_text'])
# Loop over groups using our search query
for setting in Setting.objects.all().order_by('setting'):
if (search_strings.search(_(setting.name)) or
(setting.description
and search_strings.search(_(setting.description)))
or (setting.value
and search_strings.search(setting.value))):
found_settings.append(setting)
# Scream if nothing could be found
if found_settings:
message = BasicMessage(
ungettext(
'One setting that match search criteria has been found.',
'%(count)d settings that match search criteria have been found.',
len(found_settings)) % {
'count': len(found_settings),
}, 'success')
else:
raise SearchException(
_('No settings that match search criteria has been found.'
))
else:
raise SearchException(_('Search query is empty.'))
else:
raise SearchException(_('Search query is invalid.'))
except SearchException as e:
message = BasicMessage(e.message, 'error')
return request.theme.render_to_response(
'settings/search_results.html', {
'message': message,
'groups': settings_groups,
'active_group': None,
'found_settings': found_settings,
'search_form': FormFields(form),
},
context_instance=RequestContext(request))
def check_dates(date_start, date_end, precision):
date_diff = date_end - date_start
date_diff = date_diff.seconds + date_diff.days * 86400
if ((precision == 'day' and date_diff / 86400 > 60)
or (precision == 'week' and date_diff / 604800 > 60)
or (precision == 'month' and date_diff / 2592000 > 60)
or (precision == 'year' and date_diff / 31536000 > 60)):
return BasicMessage(_('Too many many items to display on graph.'),
type='error')
elif ((precision == 'day' and date_diff / 86400 < 1)
or (precision == 'week' and date_diff / 604800 < 1)
or (precision == 'month' and date_diff / 2592000 < 1)
or (precision == 'year' and date_diff / 31536000 < 1)):
return BasicMessage(_('Too few items to display on graph'),
type='error')
return None
def __call__(self, request, target=None, slug=None):
# Fetch target?
model = None
if target:
model = self.get_and_validate_target(request, target)
if not model:
return redirect(self.get_fallback_url(request))
original_model = model
# Crash if this is invalid request
if not request.csrf.request_secure(request):
request.messages.set_flash(BasicMessage(_("Action authorization is invalid.")), 'error', self.admin.id)
return redirect(self.get_fallback_url(request))
# Do something
message, url = self.action(request, model)
request.messages.set_flash(message, message.type, self.admin.id)
if url:
return redirect(url)
return redirect(self.get_fallback_url(request))
def overview_stats(request):
"""
Allow admins to generate fancy statistic graphs for different models
"""
statistics_providers = []
models_map = {}
for model in models.get_models():
try:
getattr(model.objects, 'filter_overview')
statistics_providers.append(
(str(model.__name__).lower(), model.statistics_name))
models_map[str(model.__name__).lower()] = model
except AttributeError:
pass
if not statistics_providers:
"""
Something went FUBAR - Misago ships with some stats providers out of box
If those providers cant be found, this means Misago filesystem is corrupted
"""
return request.theme.render_to_response(
'overview/stats/not_available.html',
context_instance=RequestContext(request))
message = None
if request.method == 'POST':
form = GenerateStatisticsForm(request.POST,
provider_choices=statistics_providers,
request=request)
if form.is_valid():
date_start = form.cleaned_data['date_start']
date_end = form.cleaned_data['date_end']
if date_start > date_end:
# Reverse dates if start is after end
date_temp = date_end
date_end = date_start
date_start = date_temp
# Assert that dates are correct
if date_end == date_start:
message = BasicMessage(_('Start and end date are same'),
type='error')
elif check_dates(date_start, date_end,
form.cleaned_data['stats_precision']):
message = check_dates(date_start, date_end,
form.cleaned_data['stats_precision'])
else:
request.messages.set_flash(
BasicMessage(_('Statistical report has been created.')),
'success', 'admin_stats')
return redirect(
reverse('admin_overview_graph',
kwargs={
'model': form.cleaned_data['provider_model'],
'date_start': date_start.strftime('%Y-%m-%d'),
'date_end': date_end.strftime('%Y-%m-%d'),
'precision':
form.cleaned_data['stats_precision']
}))
else:
message = Message(request, form.non_field_errors()[0])
message.type = 'error'
else:
form = GenerateStatisticsForm(provider_choices=statistics_providers,
request=request)
return request.theme.render_to_response(
'overview/stats/form.html', {
'form': FormLayout(form),
'message': message,
},
context_instance=RequestContext(request))
def settings(request, group_id=None, group_slug=None):
# Load groups and find selected group
settings_groups = Group.objects.all().order_by('key')
if not group_id:
active_group = settings_groups[0]
group_id = active_group.pk
else:
group_id = int(group_id)
for group in settings_groups:
if group.pk == group_id:
active_group = group
break
else:
return error404(
request,
BasicMessage(
_('The requested settings group could not be found.')))
# Load selected group settings and turn them into form
group_settings = Setting.objects.filter(
group=active_group).order_by('position')
last_fieldset = (None, [])
group_form = {'layout': []}
for setting in group_settings:
# New field subgroup?
if setting.separator and last_fieldset[0] != setting.separator:
if last_fieldset[0]:
group_form['layout'].append(last_fieldset)
last_fieldset = (_(setting.separator), [])
last_fieldset[1].append(setting.pk)
group_form[setting.pk] = setting.get_field()
group_form['layout'].append(last_fieldset)
SettingsGroupForm = type('SettingsGroupForm', (Form, ), group_form)
#Submit form
message = request.messages.get_message('admin_settings')
if request.method == 'POST':
form = SettingsGroupForm(request.POST, request=request)
if form.is_valid():
for setting in form.cleaned_data.keys():
request.settings[setting] = form.cleaned_data[setting]
request.messages.set_flash(
BasicMessage(_('Configuration has been saved.')), 'success',
'admin_settings')
return redirect(
reverse('admin_settings',
kwargs={
'group_id': active_group.pk,
'group_slug': active_group.key,
}))
else:
message = Message(request, form.non_field_errors()[0])
message.type = 'error'
else:
form = SettingsGroupForm(request=request)
# Display settings group form
return request.theme.render_to_response(
'settings/settings.html', {
'message': message,
'groups': settings_groups,
'active_group': active_group,
'search_form': FormFields(SearchForm(request=request)),
'form': FormLayout(form),
'raw_form': form,
},
context_instance=RequestContext(request))
def __call__(self, request, page=0):
"""
Use widget as view
"""
# Get basic list attributes
if request.session.get(self.get_token('filter')):
self.is_filtering = True
items_total = self.set_filters(self.admin.model.objects, request.session.get(self.get_token('filter'))).count()
else:
items_total = self.admin.model.objects.count()
sorting_method = self.get_sorting(request)
paginating_method = self.get_pagination(request, items_total, page)
# List items
items = self.admin.model.objects
# Filter items?
if request.session.get(self.get_token('filter')):
items = self.set_filters(items, request.session.get(self.get_token('filter')))
else:
items = items.all()
# Sort them
items = self.sort_items(request, items, sorting_method);
# Set pagination
if self.pagination:
items = items[paginating_method['start']:paginating_method['stop']]
# Prefetch related?
if self.prefetch_related:
items = self.prefetch_related(items)
# Default message
message = request.messages.get_message(self.admin.id)
# See if we should make and handle search form
search_form = None
SearchForm = self.get_search_form(request)
if SearchForm:
if request.method == 'POST':
# New search
if request.POST.get('origin') == 'search':
search_form = SearchForm(request.POST, request=request)
if search_form.is_valid():
search_criteria = {}
for field, criteria in search_form.cleaned_data.items():
if len(criteria) > 0:
search_criteria[field] = criteria
if not search_criteria:
message = BasicMessage(_("No search criteria have been defined."))
else:
request.session[self.get_token('filter')] = search_criteria
return redirect(self.get_url())
else:
message = BasicMessage(_("Search form contains errors."))
message.type = 'error'
else:
search_form = SearchForm(request=request)
# Kill search
if request.POST.get('origin') == 'clear' and self.is_filtering and request.csrf.request_secure(request):
request.session[self.get_token('filter')] = None
request.messages.set_flash(BasicMessage(_("Search criteria have been cleared.")), 'info', self.admin.id)
return redirect(self.get_url())
else:
if self.is_filtering:
search_form = SearchForm(request=request, initial=request.session.get(self.get_token('filter')))
else:
search_form = SearchForm(request=request)
# See if we sould make and handle tab form
table_form = None
TableForm = self.get_table_form(request, items)
if TableForm:
if request.method == 'POST' and request.POST.get('origin') == 'table':
table_form = TableForm(request.POST, request=request)
if table_form.is_valid():
message, redirect_url = self.table_action(request, items, table_form.cleaned_data)
if redirect_url:
request.messages.set_flash(message, message.type, self.admin.id)
return redirect(redirect_url)
else:
message = Message(request, table_form.non_field_errors()[0])
message.type = 'error'
else:
table_form = TableForm(request=request)
# See if we should make and handle list form
list_form = None
ListForm = self.get_actions_form(items)
if ListForm:
if request.method == 'POST' and request.POST.get('origin') == 'list':
list_form = ListForm(request.POST, request=request)
if list_form.is_valid():
try:
form_action = getattr(self, 'action_' + list_form.cleaned_data['list_action'])
message, redirect_url = form_action(request, items, list_form.cleaned_data['list_items'])
if redirect_url:
request.messages.set_flash(message, message.type, self.admin.id)
return redirect(redirect_url)
except AttributeError:
message = BasicMessage(_("Action requested is incorrect."))
else:
if 'list_items' in list_form.errors:
message = BasicMessage(self.nothing_checked_message)
elif 'list_action' in list_form.errors:
message = BasicMessage(_("Action requested is incorrect."))
else:
message = Message(request, list_form.non_field_errors()[0])
message.type = 'error'
else:
list_form = ListForm(request=request)
# Render list
return request.theme.render_to_response(self.get_templates(self.template),
{
'admin': self.admin,
'action': self,
'request': request,
'url': self.get_url(),
'message': message,
'sorting': self.sortables,
'sorting_method': sorting_method,
'pagination': paginating_method,
'list_form': FormLayout(list_form) if list_form else None,
'search_form': FormLayout(search_form) if search_form else None,
'table_form': FormFields(table_form).fields if table_form else None,
'items': items,
'items_total': items_total,
},
context_instance=RequestContext(request));
