def signature(request):
# Intercept all requests if we can't use signature
if not request.acl.usercp.can_use_signature():
return error403(request)
if request.user.signature_ban:
return render_to_response('usercp/signature_banned.html',
context_instance=RequestContext(request, {
'tab': 'signature'}));
siggy_text = ''
message = request.messages.get_message('usercp_signature')
if request.method == 'POST':
form = SignatureForm(request.POST, request=request, initial={'signature': request.user.signature})
if form.is_valid():
request.user.signature = form.cleaned_data['signature']
if request.user.signature:
request.user.signature_preparsed = signature_markdown(request.acl,
request.user.signature)
else:
request.user.signature_preparsed = None
request.user.save(force_update=True)
messages.success(request, _("Your signature has been changed."), 'usercp_signature')
return redirect(reverse('usercp_signature'))
else:
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = SignatureForm(request=request, initial={'signature': request.user.signature})
return render_to_response('usercp/signature.html',
context_instance=RequestContext(request, {
'message': message,
'tab': 'signature',
'form': form}));
def form(request):
"""
Allow admins to generate fancy statistic graphs for different models
"""
models_map = {}
for model in models.get_models():
try:
getattr(model.objects, "filter_stats")
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 render_to_response("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 = Message(_("Start and end date are same"), messages.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:
messages.success(request, _("Statistical report has been created."), "admin_stats")
return redirect(
reverse(
"admin_stats_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(form.non_field_errors()[0], messages.ERROR)
else:
form = GenerateStatisticsForm(provider_choices=statistics_providers, request=request)
return render_to_response(
"stats/form.html", {"form": form, "message": message}, context_instance=RequestContext(request)
)
def form(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_stats')
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 render_to_response('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 = Message(_('Start and end date are same'), messages.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:
messages.success(request, _('Statistical report has been created.'), 'admin_stats')
return redirect(reverse('admin_stats_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(form.non_field_errors()[0], messages.ERROR)
else:
form = GenerateStatisticsForm(provider_choices=statistics_providers, request=request)
return render_to_response('stats/form.html',
{
'form': form,
'message': message,
},
context_instance=RequestContext(request));
def graph(request, model, date_start, date_end, precision):
"""
Generate fancy graph for model and stuff
"""
if date_start == date_end:
# Bad dates
raise error404(RequestContext)
# Turn stuff into datetime's
date_start = datetime.strptime(date_start, '%Y-%m-%d')
date_end = datetime.strptime(date_end, '%Y-%m-%d')
statistics_providers = []
models_map = {}
for model_obj in models.get_models():
try:
getattr(model_obj.objects, 'filter_stats')
statistics_providers.append(
(str(model_obj.__name__).lower(), model_obj.statistics_name))
models_map[str(model_obj.__name__).lower()] = model_obj
except AttributeError:
pass
if not statistics_providers:
# Like before, q.q on lack of models
return render_to_response('stats/not_available.html',
context_instance=RequestContext(request))
if not model in models_map or check_dates(date_start, date_end, precision):
# Bad model name or graph data!
raise error404(request)
form = GenerateStatisticsForm(provider_choices=statistics_providers,
request=request,
initial={
'provider_model': model,
'date_start': date_start,
'date_end': date_end,
'stats_precision': precision
})
return render_to_response('stats/graph.html', {
'title':
models_map[model].statistics_name,
'graph':
build_graph(models_map[model], date_start, date_end, precision),
'form':
form,
'message':
request.messages.get_message('admin_stats'),
},
context_instance=RequestContext(request))
def new_threads(request, page=0):
queryset = Thread.objects.filter(
forum_id__in=Forum.objects.readable_forums(request.acl)).filter(
deleted=False).filter(moderated=False)
items_total = queryset.count()
if items_total > (settings.threads_per_page * 3):
items_total = settings.threads_per_page * 3
try:
pagination = make_pagination(page, items_total,
settings.threads_per_page)
except Http404:
return redirect('new_threads')
queryset = queryset.order_by('-start').prefetch_related(
'forum')[pagination['start']:pagination['stop']]
if settings.avatars_on_threads_list:
queryset = queryset.prefetch_related('start_poster', 'last_poster')
return render_to_response(
'new_threads.html', {
'items_total': items_total,
'threads': Thread.objects.with_reads(queryset, request.user),
'prefixes': ThreadPrefix.objects.all_prefixes(),
'pagination': pagination,
},
context_instance=RequestContext(request))
def forum_map(request):
return render_to_response('forum_map.html',
{
'forums': Forum.objects.treelist(request.acl.forums,
Forum.objects.special_model('root'))
},
context_instance=RequestContext(request));
def options(request):
message = request.messages.get_message('usercp_options')
if request.method == 'POST':
form = UserForumOptionsForm(request.POST, request=request)
if form.is_valid():
request.user.hide_activity = form.cleaned_data['hide_activity']
request.user.allow_pds = form.cleaned_data['allow_pds']
request.user.receive_newsletters = form.cleaned_data['newsletters']
request.user.timezone = form.cleaned_data['timezone']
request.user.subscribe_start = form.cleaned_data['subscribe_start']
request.user.subscribe_reply = form.cleaned_data['subscribe_reply']
request.user.save(force_update=True)
messages.success(request, _("Forum options have been changed."), 'usercp_options')
return redirect(reverse('usercp'))
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = UserForumOptionsForm(request=request, initial={
'newsletters': request.user.receive_newsletters,
'hide_activity': request.user.hide_activity,
'allow_pds': request.user.allow_pds,
'timezone': request.user.timezone,
'subscribe_start': request.user.subscribe_start,
'subscribe_reply': request.user.subscribe_reply,
})
return render_to_response('usercp/options.html',
context_instance=RequestContext(request, {
'message': message,
'tab': 'options',
'form': form}));
def call(self, **kwargs):
result = self.request.session.get('search_results')
if not result:
return error404(self.request, _("No search results were found."))
items = result['search_results']
items_total = len(items);
try:
pagination = make_pagination(kwargs.get('page', 0), items_total, 12)
except Http404:
return redirect(reverse('search_results'))
return render_to_response('search/results.html',
{
'search_in': result.get('search_in'),
'search_route': result.get('search_route'),
'search_query': result['search_query'],
'search_author': result.get('search_author'),
'search_thread_titles': result.get('search_thread_titles'),
'search_thread': result.get('search_thread'),
'results': Post.objects.filter(id__in=items).select_related('forum', 'thread', 'user').order_by('-pk')[pagination['start']:pagination['stop']],
'items_total': items_total,
'pagination': pagination,
},
context_instance=RequestContext(self.request))
def thread_action_move(self):
message = None
if self.request.POST.get('do') == 'move':
form = MoveThreadsForm(self.request.POST, request=self.request, forum=self.forum)
if form.is_valid():
new_forum = form.cleaned_data['new_forum']
self.thread.move_to(new_forum)
self.thread.save(force_update=True)
self.thread.set_checkpoint(self.request, 'moved', forum=self.forum)
self.forum.sync()
self.forum.save(force_update=True)
new_forum.sync()
new_forum.save(force_update=True)
messages.success(self.request, _('Thread has been moved to "%(forum)s".') % {'forum': new_forum.name}, 'threads')
return None
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = MoveThreadsForm(request=self.request, forum=self.forum)
return render_to_response('%ss/move_thread.html' % self.type_prefix,
{
'type_prefix': self.type_prefix,
'message': message,
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'form': form,
},
context_instance=RequestContext(self.request));
def crop(request, upload=False):
if upload and (not request.user.avatar_temp or not 'upload' in settings.avatars_types):
return error404(request)
if not upload and request.user.avatar_type != 'upload':
messages.error(request, _("Crop Avatar option is avaiable only when you use uploaded image as your avatar."), 'usercp_avatar')
return redirect(reverse('usercp_avatar'))
message = request.messages.get_message('usercp_avatar')
if request.method == 'POST':
if request.csrf.request_secure(request):
try:
image_path = settings.MEDIA_ROOT + 'avatars/'
if upload:
source = Image.open(image_path + request.user.avatar_temp)
else:
source = Image.open(image_path + request.user.avatar_original)
width, height = source.size
aspect = float(width) / float(request.POST['crop_b'])
crop_x = int(aspect * float(request.POST['crop_x']))
crop_y = int(aspect * float(request.POST['crop_y']))
crop_w = int(aspect * float(request.POST['crop_w']))
crop = source.crop((crop_x, crop_y, crop_x + crop_w, crop_y + crop_w))
if upload:
image_name, image_extension = path(request.user.avatar_temp).splitext()
else:
image_name, image_extension = path(request.user.avatar_original).splitext()
image_name = '%s_%s%s' % (request.user.pk, random_string(8), image_extension)
resizeimage(crop, settings.AVATAR_SIZES[0], image_path + image_name, info=source.info, format=source.format)
for size in settings.AVATAR_SIZES[1:]:
resizeimage(crop, size, image_path + str(size) + '_' + image_name, info=source.info, format=source.format)
request.user.delete_avatar_image()
if upload:
request.user.delete_avatar_original()
request.user.avatar_type = 'upload'
request.user.avatar_original = '%s_org_%s%s' % (request.user.pk, random_string(8), image_extension)
source.save(image_path + request.user.avatar_original)
request.user.delete_avatar_temp()
request.user.avatar_image = image_name
request.user.avatar_crop = [str(float(request.POST[x])) for x in ('crop_x', 'crop_y', 'crop_w')]
request.user.save(force_update=True)
messages.success(request, _("Your avatar has been cropped."), 'usercp_avatar')
return redirect(reverse('usercp_avatar'))
except Exception:
message = Message(_("Form contains errors."), messages.ERROR)
else:
message = Message(_("Request authorisation is invalid."), messages.ERROR)
return render_to_response('usercp/avatar_crop.html',
context_instance=RequestContext(request, {
'message': message,
'after_upload': upload,
'avatar_size': settings.AVATAR_SIZES[0],
'avatar_crop': request.user.avatar_crop if not upload else None,
'source': 'avatars/%s' % (request.user.avatar_temp if upload else request.user.avatar_original),
'tab': 'avatar'}));
def posts(request, user, page=0):
queryset = user.post_set.filter(forum_id__in=Forum.objects.readable_forums(request.acl)).filter(deleted=False).filter(moderated=False)
count = queryset.count()
try:
pagination = make_pagination(page, count, 12)
except Http404:
return redirect(reverse('user_posts', kwargs={'user': user.id, 'username': user.username_slug}))
cache_key = 'user_profile_posts_graph_%s' % user.pk
graph = cache.get(cache_key, 'nada')
if graph == 'nada':
if user.posts:
graph = user.timeline(queryset.filter(date__gte=timezone.now()-timedelta(days=100)))
else:
graph = [0 for x in range(100)]
cache.set(cache_key, graph, 14400)
return render_to_response('profiles/posts.html',
context_instance=RequestContext(request, {
'profile': user,
'tab': 'posts',
'graph_max': max(graph),
'graph': (str(i) for i in graph),
'items_total': count,
'items': queryset.select_related('thread', 'forum').order_by('-id')[pagination['start']:pagination['stop']],
'pagination': pagination,
}));
def details(request, user):
return render_to_response('profiles/details.html',
context_instance=RequestContext(
request, {
'profile': user,
'tab': 'details',
}))
def form(request):
message = None
if request.method == 'POST':
form = UserSendActivationMailForm(request.POST, request=request)
if form.is_valid():
user = form.found_user
user_ban = Ban.objects.check_ban(username=user.username, email=user.email)
if user_ban:
return error_banned(request, user, user_ban)
if user.activation == User.ACTIVATION_NONE:
return redirect_message(request, messages.INFO, _("%(username)s, your account is already active.") % {'username': user.username})
if user.activation == User.ACTIVATION_ADMIN:
return redirect_message(request, messages.INFO, _("%(username)s, only board administrator can activate your account.") % {'username': user.username})
user.email_user(
request,
'users/activation/resend',
_("Account Activation"),
)
return redirect_message(request, messages.SUCCESS, _("%(username)s, e-mail containing new activation link has been sent to %(email)s.") % {'username': user.username, 'email': user.email})
else:
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = UserSendActivationMailForm(request=request)
return render_to_response('resend_activation.html',
{
'message': message,
'form': form,
},
context_instance=RequestContext(request));
def action_move(self, ids):
threads = []
for thread in self.threads:
if thread.pk in ids:
threads.append(thread)
if self.request.POST.get('origin') == 'move_form':
form = MoveThreadsForm(self.request.POST, request=self.request, forum=self.forum)
if form.is_valid():
new_forum = form.cleaned_data['new_forum']
for thread in threads:
thread.move_to(new_forum)
thread.save(force_update=True)
thread.set_checkpoint(self.request, 'moved', forum=self.forum)
thread.update_current_dates()
new_forum.sync()
new_forum.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
messages.success(self.request, _('Selected threads have been moved to "%(forum)s".') % {'forum': new_forum.name}, 'threads')
return None
self.message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = MoveThreadsForm(request=self.request, forum=self.forum)
return render_to_response('%ss/move_threads.html' % self.type_prefix,
{
'type_prefix': self.type_prefix,
'search_in': self.search_in,
'message': self.message,
'forum': self.forum,
'parents': self.parents,
'threads': threads,
'form': form,
},
context_instance=RequestContext(self.request));
def dispatch(self, request, **kwargs):
try:
next = self.post.change_set.filter(id__gt=self.change.pk)[:1][0]
compare_to = next.post_content
except IndexError:
next = None
compare_to = self.post.post
try:
prev = self.post.change_set.filter(id__lt=self.change.pk).order_by('-id')[:1][0]
except IndexError:
prev = None
self.forum.closed = self.proxy.closed
return render_to_response('%ss/changelog_diff.html' % self.type_prefix,
self._template_vars({
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'post': self.post,
'change': self.change,
'next': next,
'prev': prev,
'message': request.messages.get_message('changelog'),
'l': 1,
'diff': difflib.ndiff(self.change.post_content.splitlines(), compare_to.splitlines()),
}),
context_instance=RequestContext(request))
def form(request):
message = None
if request.method == 'POST':
form = UserResetPasswordForm(request.POST, request=request)
if form.is_valid():
user = form.found_user
user_ban = Ban.objects.check_ban(username=user.username, email=user.email)
if user_ban:
return error_banned(request, user, user_ban)
elif user.activation != User.ACTIVATION_NONE:
return redirect_message(request, messages.INFO, _("%(username)s, your account has to be activated in order for you to be able to request new password.") % {'username': user.username})
user.token = random_string(12)
user.save(force_update=True)
user.email_user(
request,
'users/password/confirm',
_("Confirm New Password Request")
)
return redirect_message(request, messages.INFO, _("%(username)s, new password request confirmation has been sent to %(email)s.") % {'username': user.username, 'email': user.email})
else:
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = UserResetPasswordForm(request=request)
return render_to_response('reset_password.html',
{
'message': message,
'form': form,
},
context_instance=RequestContext(request));
def decorator(*args, **kwargs):
request = args[0]
if request.user.avatar_ban:
return render_to_response('usercp/avatar_banned.html',
context_instance=RequestContext(request, {
'tab': 'avatar'}));
return f(*args, **kwargs)
def decorator(*args, **kwargs):
request = args[0]
if request.user.avatar_ban:
return render_to_response('usercp/avatar_banned.html',
context_instance=RequestContext(
request, {'tab': 'avatar'}))
return f(*args, **kwargs)
def thread_action_move(self):
message = None
if self.request.POST.get('do') == 'move':
form = MoveThreadsForm(self.request.POST,
request=self.request,
forum=self.forum)
if form.is_valid():
new_forum = form.cleaned_data['new_forum']
self.thread.move_to(new_forum)
self.thread.save(force_update=True)
self.thread.set_checkpoint(self.request,
'moved',
forum=self.forum)
self.forum.sync()
self.forum.save(force_update=True)
new_forum.sync()
new_forum.save(force_update=True)
messages.success(
self.request,
_('Thread has been moved to "%(forum)s".') %
{'forum': new_forum.name}, 'threads')
return None
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = MoveThreadsForm(request=self.request, forum=self.forum)
return render_to_response('%ss/move_thread.html' % self.type_prefix, {
'type_prefix': self.type_prefix,
'message': message,
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'form': form,
},
context_instance=RequestContext(
self.request))
def settings(request, group_id=None, group_slug=None):
# Load groups and find selected group
settings_groups = SettingsGroup.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, _('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 = {'fieldsets': []}
for setting in group_settings:
# New field subgroup?
if setting.separator and last_fieldset[0] != setting.separator:
if last_fieldset[0]:
group_form['fieldsets'].append(last_fieldset)
last_fieldset = (_(setting.separator), [])
last_fieldset[1].append(setting.pk)
group_form[setting.pk] = setting.get_field()
group_form['fieldsets'].append(last_fieldset)
SettingsGroupForm = type('SettingsGroupForm', (Form,), group_form)
#Submit form
message = messages.get_message(request, 'admin_settings')
if request.method == 'POST':
form = SettingsGroupForm(request.POST, request=request)
if form.is_valid():
for setting in form.cleaned_data.keys():
misago_settings[setting] = form.cleaned_data[setting]
cache.delete('settings')
messages.success(request, _('Configuration has been changed.'), 'admin_settings')
return redirect(reverse('admin_settings', kwargs={
'group_id': active_group.pk,
'group_slug': active_group.key,
}))
else:
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = SettingsGroupForm(request=request)
# Display settings group form
return render_to_response('settings/settings.html',
{
'message': message,
'groups': settings_groups,
'active_group': active_group,
'search_form': SearchForm(request=request),
'form': FormIterator(form),
'raw_form': form,
},
context_instance=RequestContext(request));
def avatar(request):
message = request.messages.get_message('usercp_avatar')
return render_to_response('usercp/avatar.html',
context_instance=RequestContext(
request, {
'message': message,
'tab': 'avatar'
}))
def __call__(self, request, target=None, slug=None):
self.request = request
# Fetch target
model = None
if target:
model = self.get_and_validate_target(target)
self.original_name = self.get_target_name(model)
if not model:
return redirect(self.get_fallback_link())
original_model = model
# Set filter
users = model.make_queryset()
total_users = users.count()
if not total_users:
messages.error(request, _('Policy "%(name)s" does not apply to any users.') % {'name': model.name}, self.admin.id)
return redirect(reverse('admin_prune_users'))
message = None
if request.method == 'POST':
deleted = 0
if request.csrf.request_secure(request):
for user in users.iterator():
if user.is_protected():
messages.info(request, _('User "%(name)s" is protected and was not deleted.') % {'name': user.username}, self.admin.id)
else:
user.delete()
deleted += 1
if deleted:
messages.success(request, ungettext(
'One user has been deleted.',
'%(deleted)d users have been deleted.',
deleted
) % {'deleted': deleted}, self.admin.id)
User.objects.resync_monitor()
else:
messages.info(request, _("No users have been deleted."), self.admin.id)
return redirect(reverse('admin_prune_users'))
else:
message = Message(_("Request authorization is invalid. Please resubmit your form."), messages.ERROR)
return render_to_response(self.get_template(),
{
'admin': self.admin,
'action': self,
'request': request,
'link': self.get_link(model),
'fallback': self.get_fallback_link(),
'messages': messages.get_messages(request, self.admin.id),
'message': message,
'tabbed': self.tabbed,
'total_users': total_users,
'target': self.get_target_name(original_model),
'target_model': original_model,
},
context_instance=RequestContext(request));
def graph(request, model, date_start, date_end, precision):
"""
Generate fancy graph for model and stuff
"""
if date_start == date_end:
# Bad dates
raise error404(RequestContext)
# Turn stuff into datetime's
date_start = datetime.strptime(date_start, "%Y-%m-%d")
date_end = datetime.strptime(date_end, "%Y-%m-%d")
statistics_providers = []
models_map = {}
for model_obj in models.get_models():
try:
getattr(model_obj.objects, "filter_stats")
statistics_providers.append((str(model_obj.__name__).lower(), model_obj.statistics_name))
models_map[str(model_obj.__name__).lower()] = model_obj
except AttributeError:
pass
if not statistics_providers:
# Like before, q.q on lack of models
return render_to_response("stats/not_available.html", context_instance=RequestContext(request))
if not model in models_map or check_dates(date_start, date_end, precision):
# Bad model name or graph data!
raise error404(request)
form = GenerateStatisticsForm(
provider_choices=statistics_providers,
request=request,
initial={"provider_model": model, "date_start": date_start, "date_end": date_end, "stats_precision": precision},
)
return render_to_response(
"stats/graph.html",
{
"title": models_map[model].statistics_name,
"graph": build_graph(models_map[model], date_start, date_end, precision),
"form": form,
"message": request.messages.get_message("admin_stats"),
},
context_instance=RequestContext(request),
)
def __call__(self, request, **kwargs):
self.request = request
self.kwargs = kwargs
self.parents = []
self.ignored = False
self.watcher = False
self.message = request.messages.get_message("threads")
try:
self._type_available()
self.fetch_thread()
self.check_forum_type()
self._check_permissions()
response = self.fetch_posts()
if response:
return response
self.make_thread_form()
if self.thread_form:
response = self.handle_thread_form()
if response:
return response
self.make_posts_form()
if self.posts_form:
response = self.handle_posts_form()
if response:
return response
except (Forum.DoesNotExist, Thread.DoesNotExist):
return error404(request)
except ACLError403 as e:
return error403(request, unicode(e))
except ACLError404 as e:
return error404(request, unicode(e))
# Merge proxy into forum
self.forum.closed = self.proxy.closed
return render_to_response(
"%ss/thread.html" % self.type_prefix,
self._template_vars(
{
"message": self.message,
"forum": self.forum,
"parents": self.parents,
"thread": self.thread,
"is_read": self.tracker.is_read(self.thread),
"count": self.count,
"posts": self.posts,
"ignored_posts": self.ignored,
"watcher": self.watcher,
"pagination": self.pagination,
"emojis": emojis(),
"quick_reply": QuickReplyForm(request=request),
"thread_form": self.thread_form or None,
"posts_form": self.posts_form or None,
}
),
context_instance=RequestContext(request),
)
def response(self):
return render_to_response('%ss/details.html' % self.type_prefix,
self._template_vars({
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'post': self.post,
}),
context_instance=RequestContext(self.request))
def graph(request, model, date_start, date_end, precision):
"""
Generate fancy graph for model and stuff
"""
if date_start == date_end:
# Bad dates
raise error404(RequestContext)
# Turn stuff into datetime's
date_start = datetime.strptime(date_start, '%Y-%m-%d')
date_end = datetime.strptime(date_end, '%Y-%m-%d')
statistics_providers = []
models_map = {}
for model_obj in models.get_models():
try:
getattr(model_obj.objects, 'filter_stats')
statistics_providers.append((str(model_obj.__name__).lower(), model_obj.statistics_name))
models_map[str(model_obj.__name__).lower()] = model_obj
except AttributeError:
pass
if not statistics_providers:
# Like before, q.q on lack of models
return render_to_response('stats/not_available.html',
context_instance=RequestContext(request));
if not model in models_map or check_dates(date_start, date_end, precision):
# Bad model name or graph data!
raise error404(request)
form = GenerateStatisticsForm(
provider_choices=statistics_providers,
request=request,
initial={'provider_model': model, 'date_start': date_start, 'date_end': date_end, 'stats_precision': precision})
return render_to_response('stats/graph.html',
{
'title': models_map[model].statistics_name,
'graph': build_graph(models_map[model], date_start, date_end, precision),
'form': form,
'message': request.messages.get_message('admin_stats'),
},
context_instance=RequestContext(request));
def dispatch(self, request, **kwargs):
return render_to_response('%ss/changelog.html' % self.type_prefix,
self._template_vars({
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'post': self.post,
'edits': self.post.change_set.prefetch_related('user').order_by('-id')
}),
context_instance=RequestContext(request))
def index(request):
return render_to_response('index.html',
{
'users': monitor['users'],
'users_inactive': monitor['users_inactive'],
'threads': monitor['threads'],
'posts': monitor['posts'],
'admins': Session.objects.filter(user__isnull=False).filter(admin=1).order_by('user__username_slug').select_related('user'),
},
context_instance=RequestContext(request));
def response(self):
return render_to_response('%ss/details.html' % self.type_prefix,
self._template_vars({
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'post': self.post,
}),
context_instance=RequestContext(
self.request))
def send(request, target, token):
try:
newsletter = Newsletter.objects.get(pk=target, token=token)
# Build recipients queryset
recipients = User.objects
if newsletter.ranks.all():
recipients = recipients.filter(rank__in=[x.pk for x in newsletter.ranks.all()])
if not newsletter.ignore_subscriptions:
recipients = recipients.filter(receive_newsletters=1)
recipients_total = recipients.count()
if recipients_total < 1:
messages.error(request, _('No recipients for newsletter "%(newsletter)s" could be found.') % {'newsletter': newsletter.name}, 'newsletters')
return redirect(reverse('admin_newsletters'))
for user in recipients.all()[newsletter.progress:(newsletter.progress + newsletter.step_size)]:
tokens = {
'{{ board_name }}': settings.board_name,
'{{ username }}': user.username,
'{{ user_link }}': django_reverse('user', kwargs={'username': user.username_slug, 'user': user.pk}),
'{{ board_link }}': settings.BOARD_ADDRESS,
}
subject = newsletter.parse_name(tokens)
user.email_user(request, 'users/newsletter', subject, {
'newsletter': newsletter,
'subject': subject,
'content_html': newsletter.parse_html(tokens),
'content_plain': newsletter.parse_plain(tokens),
})
newsletter.progress += 1
newsletter.generate_token()
newsletter.save(force_update=True)
if newsletter.progress >= recipients_total:
newsletter.progress = 0
newsletter.save(force_update=True)
messages.success(request, _('Newsletter "%(newsletter)s" has been sent.') % {'newsletter': newsletter.name}, 'newsletters')
return redirect(reverse('admin_newsletters'))
# Render Progress
response = render_to_response('processing.html',
{
'task_name': _('Sending Newsletter'),
'target_name': newsletter.name,
'message': _('Sent to %(progress)s from %(total)s users') % {'progress': newsletter.progress, 'total': recipients_total},
'progress': newsletter.progress * 100 / recipients_total,
'cancel_link': reverse('admin_newsletters'),
},
context_instance=RequestContext(request));
response['refresh'] = '2;url=%s' % reverse('admin_newsletters_send', newsletter)
return response
except Newsletter.DoesNotExist:
messages.error(request, _('Requested Newsletter could not be found.'), 'newsletters')
return redirect(reverse('admin_newsletters'))
def username(request):
if not request.acl.usercp.show_username_change():
return error404(request)
changes_left = request.acl.usercp.changes_left(request.user)
next_change = None
if request.acl.usercp.changes_expire() and not changes_left:
next_change = request.user.namechanges.filter(
date__gte=timezone.now() - timedelta(days=request.acl.usercp.acl['changes_expire']),
).order_by('-date')[0]
next_change = next_change.date + timedelta(days=request.acl.usercp.acl['changes_expire'])
message = request.messages.get_message('usercp_username')
if request.method == 'POST':
if not changes_left:
message = Message(_("You have exceeded the maximum number of name changes."), messages.ERROR)
form = UsernameChangeForm(request=request)
else:
org_username = request.user.username
form = UsernameChangeForm(request.POST, request=request)
if form.is_valid():
request.user.set_username(form.cleaned_data['username'])
request.user.save(force_update=True)
request.user.sync_username()
request.user.namechanges.create(date=timezone.now(), old_username=org_username)
messages.success(request, _("Your username has been changed."), 'usercp_username')
# Alert followers of namechange
alert_time = timezone.now()
bulk_alerts = []
alerted_users = []
for follower in request.user.follows_set.iterator():
alerted_users.append(follower.pk)
alert = Alert(user=follower, message=ugettext_lazy("User that you are following, %(username)s, has changed his name to %(newname)s").message, date=alert_time)
alert.strong('username', org_username)
alert.profile('newname', request.user)
alert.hydrate()
bulk_alerts.append(alert)
if bulk_alerts:
Alert.objects.bulk_create(bulk_alerts)
User.objects.filter(id__in=alerted_users).update(alerts=F('alerts') + 1)
# Hop back
return redirect(reverse('usercp_username'))
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = UsernameChangeForm(request=request)
return render_to_response('usercp/username.html',
context_instance=RequestContext(request, {
'message': message,
'changes_left': changes_left,
'form': form,
'next_change': next_change,
'changes_history': request.user.namechanges.order_by('-date')[:10],
'tab': 'username'}));
def response(self):
return render_to_response('%ss/karmas.html' % self.type_prefix,
self._template_vars({
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'post': self.post,
'upvotes': self.post.karma_set.filter(score=1),
'downvotes': self.post.karma_set.filter(score=-1),
}),
context_instance=RequestContext(self.request))
def resync_forums(request, forum=0, progress=0):
progress = int(progress)
forums = request.session.get('sync_forums')
if not forums:
messages.info(request, _('No forums to resynchronize.'), 'forums')
return redirect(reverse('admin_forums'))
try:
if not forum:
forum = request.session['sync_forums'].pop()
forum = Forum.objects.get(id=forum)
except Forum.DoesNotExist:
del request.session['sync_forums']
messages.error(request,
_('Forum for resynchronization does not exist.'),
'forums')
return redirect(reverse('admin_forums'))
# Sync 50 threads
threads_total = forum.thread_set.count()
for thread in forum.thread_set.all()[progress:(progress + 1)]:
thread.sync()
thread.save(force_update=True)
progress += 1
if not threads_total:
return redirect(django_reverse('admin_forums_resync'))
# Render Progress
response = render_to_response('processing.html', {
'task_name': _('Resynchronizing Forums'),
'target_name': forum.name,
'message': _('Resynchronized %(progress)s from %(total)s threads') % {
'progress': progress,
'total': threads_total
},
'progress': progress * 100 / threads_total,
'cancel_link': reverse('admin_forums'),
},
context_instance=RequestContext(request))
# Redirect where to?
if progress >= threads_total:
forum.sync()
forum.save(force_update=True)
response['refresh'] = '2;url=%s' % django_reverse(
'admin_forums_resync')
else:
response['refresh'] = '2;url=%s' % django_reverse(
'admin_forums_resync',
kwargs={
'forum': forum.pk,
'progress': progress
})
return response
def post_action_split(self, ids):
for id in ids:
if id == self.thread.start_post_id:
raise forms.ValidationError(_("You cannot split first post from thread."))
message = None
if self.request.POST.get("do") == "split":
form = SplitThreadForm(self.request.POST, request=self.request)
if form.is_valid():
new_thread = Thread()
new_thread.forum = form.cleaned_data["thread_forum"]
new_thread.name = form.cleaned_data["thread_name"]
new_thread.slug = slugify(form.cleaned_data["thread_name"])
new_thread.start = timezone.now()
new_thread.last = timezone.now()
new_thread.start_poster_name = "n"
new_thread.start_poster_slug = "n"
new_thread.last_poster_name = "n"
new_thread.last_poster_slug = "n"
new_thread.save(force_insert=True)
for post in self.posts:
if post.pk in ids:
post.move_to(new_thread)
post.save(force_update=True)
new_thread.sync()
new_thread.save(force_update=True)
self.thread.sync()
self.thread.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
if new_thread.forum != self.forum:
new_thread.forum.sync()
new_thread.forum.save(force_update=True)
messages.success(self.request, _("Selected posts have been split to new thread."), "threads")
return redirect(reverse(self.type_prefix, kwargs={"thread": new_thread.pk, "slug": new_thread.slug}))
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = SplitThreadForm(
request=self.request,
initial={"thread_name": _("[Split] %s") % self.thread.name, "thread_forum": self.forum},
)
return render_to_response(
"%ss/split.html" % self.type_prefix,
{
"type_prefix": self.type_prefix,
"message": message,
"forum": self.forum,
"parents": self.parents,
"thread": self.thread,
"posts": ids,
"form": form,
},
context_instance=RequestContext(self.request),
)
def __call__(self, request, **kwargs):
self.request = request
self.kwargs = kwargs
self.parents = []
self.ignored = False
self.watcher = False
self.message = request.messages.get_message('threads')
try:
self._type_available()
self.fetch_thread()
self.check_forum_type()
self._check_permissions()
response = self.fetch_posts()
if response:
return response
self.make_thread_form()
if self.thread_form:
response = self.handle_thread_form()
if response:
return response
self.make_posts_form()
if self.posts_form:
response = self.handle_posts_form()
if response:
return response
except (Forum.DoesNotExist, Thread.DoesNotExist):
return error404(request)
except ACLError403 as e:
return error403(request, unicode(e))
except ACLError404 as e:
return error404(request, unicode(e))
# Merge proxy into forum
self.forum.closed = self.proxy.closed
return render_to_response('%ss/thread.html' % self.type_prefix,
self._template_vars({
'message': self.message,
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'is_read': self.tracker.is_read(self.thread),
'count': self.count,
'posts': self.posts,
'ignored_posts': self.ignored,
'watcher': self.watcher,
'pagination': self.pagination,
'emojis': emojis(),
'quick_reply': QuickReplyForm(request=request),
'thread_form': self.thread_form or None,
'posts_form': self.posts_form or None,
}),
context_instance=RequestContext(request));
def watched_threads(request, page=0, new=False):
# Find mode and fetch threads
readable_forums = Forum.objects.readable_forums(request.acl, True)
starter_readable_forums = Forum.objects.starter_readable_forums(request.acl)
if not readable_forums and not readable_forums:
return error403(request, _("%(username), you cannot read any forums.") % {'username': request.user.username})
private_threads_pk = Forum.objects.special_pk('private_threads')
if not settings.enable_private_threads and private_threads_pk in readable_forums:
readable_forums.remove(private_threads_pk)
queryset = WatchedThread.objects.filter(user=request.user).filter(thread__moderated=False).filter(thread__deleted=False).select_related('thread')
if starter_readable_forums and readable_forums:
queryset = queryset.filter(Q(forum_id__in=readable_forums) | Q(forum_id__in=starter_readable_forums, starter_id=request.user.pk))
elif starter_readable_forums:
queryset = queryset.filter(starter_id__in=request.user.pk).filter(forum_id__in=starter_readable_forums)
else:
queryset = queryset.filter(forum_id__in=readable_forums)
if settings.avatars_on_threads_list:
queryset = queryset.prefetch_related('thread__last_poster')
if new:
queryset = queryset.filter(last_read__lt=F('thread__last'))
count = queryset.count()
try:
pagination = make_pagination(page, count, settings.threads_per_page)
except Http404:
if new:
return redirect(reverse('watched_threads_new'))
return redirect(reverse('watched_threads'))
queryset = queryset.order_by('-thread__last')
if settings.threads_per_page < count:
queryset = queryset[pagination['start']:pagination['stop']]
queryset.prefetch_related('thread__forum', 'thread__start_poster', 'thread__last_poster')
threads = []
for thread in queryset:
thread.thread.send_email = thread.email
thread.thread.is_read = thread.thread.last <= thread.last_read
threads.append(thread.thread)
# Display page
return render_to_response('watched.html',
{
'items_total': count,
'pagination': pagination,
'new': new,
'threads': threads,
'prefixes': ThreadPrefix.objects.all_prefixes(),
'message': request.messages.get_message('threads'),
},
context_instance=RequestContext(request))
def gallery(request):
if not 'gallery' in settings.avatars_types:
return error404(request)
allowed_avatars = []
galleries = []
for directory in path(
settings.STATICFILES_DIRS[0]).joinpath('avatars').dirs():
if directory[-7:] != '_locked' and directory[-8:] != '_default':
gallery = {'name': directory[-7:], 'avatars': []}
avatars = directory.files('*.gif')
avatars += directory.files('*.jpg')
avatars += directory.files('*.jpeg')
avatars += directory.files('*.png')
for item in avatars:
gallery['avatars'].append('/'.join(path(item).splitall()[-2:]))
galleries.append(gallery)
allowed_avatars += gallery['avatars']
if not allowed_avatars:
messages.info(request,
_("No avatar galleries are available at the moment."),
'usercp_avatar')
return redirect(reverse('usercp_avatar'))
message = request.messages.get_message('usercp_avatar')
if request.method == 'POST':
if request.csrf.request_secure(request):
new_avatar = request.POST.get('avatar_image')
if new_avatar in allowed_avatars:
request.user.delete_avatar()
request.user.avatar_type = 'gallery'
request.user.avatar_image = new_avatar
request.user.save(force_update=True)
messages.success(
request,
_("Your avatar has been changed to one from gallery."),
'usercp_avatar')
return redirect(reverse('usercp_avatar'))
message = Message(_("Selected Avatar is incorrect."),
messages.ERROR)
else:
message = Message(_("Request authorisation is invalid."),
messages.ERROR)
return render_to_response('usercp/avatar_gallery.html',
context_instance=RequestContext(
request, {
'message': message,
'galleries': galleries,
'tab': 'avatar'
}))
def render_to_response(self, template, form, context):
context['search_route'] = self.search_route
context['form'] = form
for i in ('search_query', 'search_in', 'search_author', 'search_thread_titles'):
if self.request.POST.get(i):
context[i] = self.request.POST.get(i)
try:
context['search_thread'] = self.thread_clean
except AttributeError:
pass
return render_to_response('search/%s.html' % template,
context,
context_instance=RequestContext(self.request))
def post_action_split(self, ids):
for id in ids:
if id == self.thread.start_post_id:
raise forms.ValidationError(_("You cannot split first post from thread."))
message = None
if self.request.POST.get('do') == 'split':
form = SplitThreadForm(self.request.POST, request=self.request)
if form.is_valid():
new_thread = Thread()
new_thread.forum = form.cleaned_data['thread_forum']
new_thread.name = form.cleaned_data['thread_name']
new_thread.slug = slugify(form.cleaned_data['thread_name'])
new_thread.start = timezone.now()
new_thread.last = timezone.now()
new_thread.start_poster_name = 'n'
new_thread.start_poster_slug = 'n'
new_thread.last_poster_name = 'n'
new_thread.last_poster_slug = 'n'
new_thread.save(force_insert=True)
for post in self.posts:
if post.pk in ids:
post.move_to(new_thread)
post.save(force_update=True)
new_thread.sync()
new_thread.save(force_update=True)
self.thread.sync()
self.thread.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
if new_thread.forum != self.forum:
new_thread.forum.sync()
new_thread.forum.save(force_update=True)
messages.success(self.request, _("Selected posts have been split to new thread."), 'threads')
return redirect(reverse(self.type_prefix, kwargs={'thread': new_thread.pk, 'slug': new_thread.slug}))
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = SplitThreadForm(request=self.request, initial={
'thread_name': _('[Split] %s') % self.thread.name,
'thread_forum': self.forum,
})
return render_to_response('%ss/split.html' % self.type_prefix,
{
'type_prefix': self.type_prefix,
'message': message,
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'posts': ids,
'form': form,
},
context_instance=RequestContext(self.request));
def error_banned(request, user=None, ban=None):
if not ban:
ban = request.ban
if request.is_ajax():
return json_response(request, status=403, message=_("You are banned."))
response = render_to_response('error403_banned.html', {
'banned_user': user,
'ban': ban,
'hide_signin': True,
'exception_response': True,
},
context_instance=RequestContext(request))
response.status_code = 403
return response
def __call__(self, request, **kwargs):
self.request = request
self.kwargs = kwargs
self.pagination = {}
self.parents = []
self.threads = []
self.message = request.messages.get_message('threads')
try:
self._type_available()
self._fetch_forum()
self._check_permissions()
response = self.fetch_threads()
if response:
return response
self.form = None
self.make_form()
if self.form:
response = self.handle_form()
if response:
return response
except (Forum.DoesNotExist, Thread.DoesNotExist):
return error404(request)
except ACLError403 as e:
return error403(request, unicode(e))
except ACLError404 as e:
return error404(request, unicode(e))
# Merge proxy into forum
self.forum.closed = self.proxy.closed
return render_to_response('%ss/%s.html' %
(self.type_prefix, self.template),
self._template_vars({
'message':
self.message,
'forum':
self.forum,
'parents':
self.parents,
'count':
self.count,
'list_form':
self.form or None,
'threads':
self.threads,
'pagination':
self.pagination,
}),
context_instance=RequestContext(request))
def index(request):
return render_to_response('index.html', {
'users':
monitor['users'],
'users_inactive':
monitor['users_inactive'],
'threads':
monitor['threads'],
'posts':
monitor['posts'],
'admins':
Session.objects.filter(user__isnull=False).filter(
admin=1).order_by('user__username_slug').select_related('user'),
},
context_instance=RequestContext(request))
def followers(request, user, page=0):
queryset = user.follows_set.order_by('username_slug')
count = queryset.count()
try:
pagination = make_pagination(page, count, 24)
except Http404:
return redirect(reverse('user_followers', kwargs={'user': user.id, 'username': user.username_slug}))
return render_to_response('profiles/followers.html',
context_instance=RequestContext(request, {
'profile': user,
'tab': 'followers',
'items_total': count,
'items': queryset[pagination['start']:pagination['stop']],
'pagination': pagination,}));
def render_to_response(self, template, form, context):
context['search_route'] = self.search_route
context['form'] = form
for i in ('search_query', 'search_in', 'search_author',
'search_thread_titles'):
if self.request.POST.get(i):
context[i] = self.request.POST.get(i)
try:
context['search_thread'] = self.thread_clean
except AttributeError:
pass
return render_to_response('search/%s.html' % template,
context,
context_instance=RequestContext(
self.request))
def index(request):
sessions_expiration = timezone.now() - timedelta(seconds=settings.online_counting_frequency)
admin_sessions = Session.objects.filter(user__isnull=False).filter(admin=1)
admin_sessions = admin_sessions.filter(last__gte=sessions_expiration)
admin_sessions = admin_sessions.order_by('user__username_slug').select_related('user')
return render_to_response('index.html',
{
'users': monitor['users'],
'users_inactive': monitor['users_inactive'],
'threads': monitor['threads'],
'posts': monitor['posts'],
'admins': admin_sessions,
},
context_instance=RequestContext(request))
def post_action_move(self, ids):
message = None
if self.request.POST.get('do') == 'move':
form = MovePostsForm(self.request.POST,
request=self.request,
thread=self.thread)
if form.is_valid():
thread = form.cleaned_data['thread_url']
for post in self.posts:
if post.pk in ids:
post.move_to(thread)
post.save(force_update=True)
if self.thread.post_set.count() == 0:
self.thread.delete()
else:
self.thread.sync()
self.thread.save(force_update=True)
thread.sync()
thread.save(force_update=True)
thread.forum.sync()
thread.forum.save(force_update=True)
if self.forum.pk != thread.forum.pk:
self.forum.sync()
self.forum.save(force_update=True)
messages.success(
self.request,
_("Selected posts have been moved to new thread."),
'threads')
return redirect(
reverse(self.type_prefix,
kwargs={
'thread': thread.pk,
'slug': thread.slug
}))
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = MovePostsForm(request=self.request)
return render_to_response('%ss/move_posts.html' % self.type_prefix, {
'type_prefix': self.type_prefix,
'message': message,
'forum': self.forum,
'parents': self.parents,
'thread': self.thread,
'posts': ids,
'form': form,
},
context_instance=RequestContext(
self.request))
def dispatch(self, request, **kwargs):
return render_to_response(
'%ss/changelog.html' % self.type_prefix,
self._template_vars({
'forum':
self.forum,
'parents':
self.parents,
'thread':
self.thread,
'post':
self.post,
'edits':
self.post.change_set.prefetch_related('user').order_by('-id')
}),
context_instance=RequestContext(request))
def settings_search(request):
settings_groups = SettingsGroup.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 = Message(
ungettext(
'One setting that matches search criteria has been found.',
'%(count)d settings that match search criteria have been found.',
len(found_settings)) % {
'count': len(found_settings),
}, messages.SUCCESS)
else:
raise SearchException(
_('No settings that match search criteria have been found.'
))
else:
raise SearchException(_('Search query is empty.'))
else:
raise SearchException(_('Search query is invalid.'))
except SearchException as e:
message = Message(unicode(e), messages.ERROR)
return render_to_response('settings/search_results.html', {
'message': message,
'groups': settings_groups,
'active_group': None,
'found_settings': found_settings,
'search_form': form,
},
context_instance=RequestContext(request))
def newsfeed(request):
follows = []
for user in request.user.follows.iterator():
follows.append(user.pk)
queryset = []
if follows:
queryset = Post.objects.filter(forum_id__in=Forum.objects.readable_forums(request.acl))
queryset = queryset.filter(deleted=False).filter(moderated=False)
queryset = queryset.filter(user_id__in=follows)
queryset = queryset.prefetch_related('thread', 'forum', 'user').order_by('-id')
queryset = queryset[:18]
return render_to_response('newsfeed.html',
{
'follows': follows,
'posts': queryset,
},
context_instance=RequestContext(request))
def posts(request, user, page=0):
queryset = user.post_set.filter(
forum_id__in=Forum.objects.readable_forums(request.acl)).filter(
deleted=False).filter(moderated=False)
count = queryset.count()
try:
pagination = make_pagination(page, count, 12)
except Http404:
return redirect(
reverse('user_posts',
kwargs={
'user': user.id,
'username': user.username_slug
}))
cache_key = 'user_profile_posts_graph_%s' % user.pk
graph = cache.get(cache_key, 'nada')
if graph == 'nada':
if user.posts:
graph = user.timeline(
queryset.filter(date__gte=timezone.now() -
timedelta(days=100)))
else:
graph = [0 for x in range(100)]
cache.set(cache_key, graph, 14400)
return render_to_response(
'profiles/posts.html',
context_instance=RequestContext(
request, {
'profile':
user,
'tab':
'posts',
'graph_max':
max(graph),
'graph': (str(i) for i in graph),
'items_total':
count,
'items':
queryset.select_related('thread', 'forum').order_by('-id')
[pagination['start']:pagination['stop']],
'pagination':
pagination,
}))
def form(request):
message = None
if request.method == 'POST':
form = UserSendActivationMailForm(request.POST, request=request)
if form.is_valid():
user = form.found_user
user_ban = Ban.objects.check_ban(username=user.username,
email=user.email)
if user_ban:
return error_banned(request, user, user_ban)
if user.activation == User.ACTIVATION_NONE:
return redirect_message(
request, messages.INFO,
_("%(username)s, your account is already active.") %
{'username': user.username})
if user.activation == User.ACTIVATION_ADMIN:
return redirect_message(
request, messages.INFO,
_("%(username)s, only board administrator can activate your account."
) % {'username': user.username})
user.email_user(
request,
'users/activation/resend',
_("Account Activation"),
)
return redirect_message(
request, messages.SUCCESS,
_("%(username)s, e-mail containing new activation link has been sent to %(email)s."
) % {
'username': user.username,
'email': user.email
})
else:
message = Message(form.non_field_errors()[0], messages.ERROR)
else:
form = UserSendActivationMailForm(request=request)
return render_to_response('resend_activation.html', {
'message': message,
'form': form,
},
context_instance=RequestContext(request))
def response(self):
return render_to_response('%ss/karmas.html' % self.type_prefix,
self._template_vars({
'forum':
self.forum,
'parents':
self.parents,
'thread':
self.thread,
'post':
self.post,
'upvotes':
self.post.karma_set.filter(score=1),
'downvotes':
self.post.karma_set.filter(score=-1),
}),
context_instance=RequestContext(
self.request))
def error_view(request, error, message=None):
if message:
message = unicode(message)
if request.is_ajax():
if not message:
if error == 404:
message = _("Requested page could not be loaded.")
if error == 403:
message = _("You don't have permission to see requested page.")
return json_response(request, status=error, message=message)
response = render_to_response(('error%s.html' % error), {
'message': message,
'hide_signin': True,
'exception_response': True,
},
context_instance=RequestContext(request))
response.status_code = error
return response