def view(request):
self.fetch_poll()
if 'show_results' in request.POST:
if not self.poll.user_votes:
self.poll.make_empty_vote(request)
self.poll.save()
return self.poll_redirect()
if 'show_options' in request.POST:
if self.poll.user_votes and not self.poll.user_votes[0].option_id:
self.poll.retract_votes(self.poll.user_votes)
self.poll.save()
return self.poll_redirect()
if 'change_vote' in request.POST:
if self.poll.user_votes and self.poll.user_votes[0].option_id and self.poll.vote_changing:
self.poll.retract_votes(self.poll.user_votes)
self.poll.save()
return self.poll_redirect()
if self.poll.user_votes and self.poll.user_votes[0].option_id and not self.poll.vote_changing:
messages.error(_("Changing vote in this poll is not allowed."), 'poll_%s' % self.poll.pk)
return self.poll_redirect()
form = PollVoteForm(self.request.POST, request=self.request, poll=self.poll)
if form.is_valid():
if self.poll.user_votes:
self.poll.retract_votes(self.poll.user_votes)
self.poll.make_vote(self.request, form.cleaned_data['options'])
self.poll.save()
messages.success(self.request, _("Your vote has been cast."), 'poll_%s' % self.poll.pk)
elif 'options' in form.errors:
messages.error(self.request, form.errors['options'][0], 'poll_%s' % self.poll.pk)
return self.poll_redirect()
def after_thread_action_normal(self):
self.thread.set_checkpoint(self.request, 'bogus')
if self.thread.original_weight == 2:
with UpdatingMonitor() as cm:
monitor.decrease('reported_posts')
messages.success(self.request, _('Report has been set as bogus.'),
'threads')
def register(request, form):
need_activation = User.ACTIVATION_USER
new_user = User.objects.create_user(
form.cleaned_data['username'],
form.cleaned_data['email'],
form.cleaned_data['password1'],
ip=request.session.get_ip(request),
agent=request.META.get('HTTP_USER_AGENT'),
activation=need_activation,
request=request)
if need_activation == User.ACTIVATION_USER:
# Mail user activation e-mail
messages.success(
request,
_(u"%(username)s, sua conta foi criada, mas você precisará confirmar seu email para poder usar o site. Te enviamos um email com seu token de ativação."
) % {'username': new_user.username})
new_user.email_user(
request,
'users/activation/user',
_(u"Olá, %(username)s!") % {'username': new_user.username},
)
User.objects.resync_monitor()
return new_user
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 post_action_undelete(self, ids):
undeleted = []
for post in self.posts:
if post.pk in ids and post.deleted:
undeleted.append(post.pk)
if undeleted:
update_kwargs = {
'deleted': False,
'current_date': timezone.now(),
'edit_user': self.request.user,
'edit_user_name': self.request.user.username,
'edit_user_slug': self.request.user.username_slug,
}
self.thread.post_set.filter(id__in=undeleted).update(
**update_kwargs)
self.thread.sync()
self.thread.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
messages.success(self.request,
_('Selected posts have been restored.'),
'threads')
else:
messages.info(self.request, _('No posts were restored.'),
'threads')
def profile(request):
instance = request.user.profile.members
form = EditProfile(request.POST or None, instance=instance)
if form.is_valid():
messages.success(request, (u"Informações alteradas!"))
form.save()
return render(request, 'party/profile.html', {'form': form})
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 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 destroy_user(request, user, username):
try:
user = User.objects.get(pk=user)
except User.DoesNotExist:
return error404(request)
if user.pk == request.user.pk:
return error403(request, _("You can't destroy your own account."))
try:
request.acl.destroy_users.allow_destroy_user(user)
except ACLError403 as e:
return error403(request, unicode(e))
forums_to_sync = []
for thread in user.thread_set.iterator():
if not thread.forum_id in forums_to_sync:
forums_to_sync.append(thread.forum_id)
thread.delete()
if forums_to_sync:
for forum in Forum.objects.filter(id__in=forums_to_sync).iterator():
forum.sync()
forum.save()
user.post_set.update(deleted=True)
user.delete()
messages.success(request, _('User Account "%(username)s" has been destroyed.') % {'username': user.username})
return redirect('users')
def texts(request):
if request.method == 'POST':
text_type = request.POST['id']
title1 = request.POST['title1']
text1 = request.POST['text1']
title2 = request.POST['title2']
text2 = request.POST['text2']
texts = Text().get_text()
if text_type == "home":
texts.home_1_title, texts.home_1_text, texts.home_2_title, texts.home_2_text = title1, text1, title2, text2
elif text_type == "consu":
texts.consu_1_title, texts.consu_1_text, texts.consu_2_title, texts.consu_2_text = title1, text1, title2, text2
elif text_type == "about":
texts.us_1_title, texts.us_1_text, texts.us_2_title, texts.us_2_text = title1, text1, title2, text2
elif text_type == "join":
texts.join_1_title, texts.join_1_text, texts.join_2_title, texts.join_2_text = title1, text1, title2, text2
elif text_type == "promise":
texts.promise_1_title, texts.promise_1_text, texts.promise_2_title, texts.promise_2_text = title1, text1, title2, text2
else:
dfdg
texts.save()
messages.success(request, ("Textos alterados!"))
return redirect(reverse('party_texts'))
texts = {
'home': Text().get_text().home(),
'consu': Text().get_text().consu(),
'about': Text().get_text().about(),
'join': Text().get_text().join(),
'promise': Text().get_text().promise(),
}
return render(request, 'party/texts.html', {'texts': texts})
def post_action_merge(self, ids):
users = []
posts = []
for post in self.posts:
if post.pk in ids:
posts.append(post)
if not post.user_id in users:
users.append(post.user_id)
if len(users) > 1:
raise forms.ValidationError(
_("You cannot merge replies made by different members!"
))
if len(posts) < 2:
raise forms.ValidationError(
_("You have to select two or more posts you want to merge."))
new_post = posts[0]
for post in posts[1:]:
post.merge_with(new_post)
post.delete()
md, new_post.post_preparsed = post_markdown(new_post.post)
new_post.sync_attachments()
new_post.save(force_update=True)
self.thread.sync()
self.thread.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
messages.success(
self.request,
_('Selected posts have been merged into one message.'), 'threads')
def activate(request, token):
new_credentials = request.session.get("new_credentials")
if not new_credentials or new_credentials["token"] != token:
return error404(request)
if new_credentials["new_email"]:
request.user.set_email(new_credentials["new_email"])
if new_credentials["new_password"]:
request.user.set_password(new_credentials["new_password"])
try:
request.user.full_clean()
request.user.save(force_update=True)
request.user.sessions.exclude(id=request.session.id).delete()
request.user.signin_tokens.all().delete()
messages.success(
request,
_("%(username)s, your Sign-In credentials have been changed.") % {"username": request.user.username},
"security",
)
request.session.sign_out(request)
del request.session["new_credentials"]
return redirect(reverse("sign_in"))
except ValidationError:
messages.error(
request, _("Your new credentials have been invalidated. Please try again."), "usercp_credentials"
)
return redirect(reverse("usercp_credentials"))
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 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 ignore(request, user):
if request.user.pk == user.pk:
return error404(request)
if not request.user.is_ignoring(user):
messages.success(request, _("You are now ignoring %(username)s") % {'username': user.username})
request.user.ignores.add(user)
return fallback(request)
def action_prefix(self, ids, prefix):
prefixes = self.prefixes
try:
prefix = int(prefix)
except TypeError:
prefix = 0
prefix = prefix or None
if prefix:
if self._action_set_prefix(ids, prefixes[prefix]):
messages.success(
self.request,
_('Selected threads prefix has been changed to "%(name)s".'
) % {'name': _(prefixes[prefix].name)}, 'threads')
else:
messages.info(self.request,
_('No threads prefix was changed.'), 'threads')
else:
if self._action_remove_prefix(ids):
messages.success(
self.request,
_('Selected threads prefix has been removed.'), 'threads')
else:
messages.info(self.request,
_('No threads prefixes were removed.'),
'threads')
def activate(request, token):
new_credentials = request.session.get('new_credentials')
if not new_credentials or new_credentials['token'] != token:
return error404(request)
if new_credentials['new_email']:
request.user.set_email(new_credentials['new_email'])
if new_credentials['new_password']:
request.user.set_password(new_credentials['new_password'])
try:
request.user.full_clean()
request.user.save(force_update=True)
request.user.sessions.exclude(id=request.session.id).delete()
request.user.signin_tokens.all().delete()
messages.success(
request,
_("%(username)s, your Sign-In credentials have been changed.") %
{'username': request.user.username}, 'security')
request.session.sign_out(request)
del request.session['new_credentials']
return redirect(reverse('sign_in'))
except ValidationError:
messages.error(
request,
_("Your new credentials have been invalidated. Please try again."),
'usercp_credentials')
return redirect(reverse('usercp_credentials'))
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 make_jump(self):
username = slugify(self.request.POST.get('username', '').strip())
if not username:
messages.error(self.request, _('You have to enter name of user you want to invite to thread.'), 'threads')
return self.retreat_redirect()
try:
user = User.objects.get(username_slug=username)
acl = user.acl()
if user in self.thread.participants.all():
if user.pk == self.request.user.pk:
messages.error(self.request, _('You cannot add yourself to this thread.'), 'threads')
else:
messages.info(self.request, _('%(user)s is already participating in this thread.') % {'user': user.username}, 'threads')
elif not acl.private_threads.can_participate():
messages.info(self.request, _('%(user)s cannot participate in private threads.') % {'user': user.username}, 'threads')
elif (not self.request.acl.private_threads.can_invite_ignoring() and
not user.allow_pd_invite(self.request.user)):
messages.info(self.request, _('%(user)s restricts who can invite him to private threads.') % {'user': user.username}, 'threads')
else:
self.thread.participants.add(user)
user.sync_pds = True
user.save(force_update=True)
user.email_user(self.request, 'private_thread_invite', _("You've been invited to private thread \"%(thread)s\" by %(user)s") % {'thread': self.thread.name, 'user': self.request.user.username}, {'author': self.request.user, 'thread': self.thread})
self.thread.set_checkpoint(self.request, 'invited', user)
messages.success(self.request, _('%(user)s has been added to this thread.') % {'user': user.username}, 'threads')
except User.DoesNotExist:
messages.error(self.request, _('User with requested username could not be found.'), 'threads')
return self.retreat_redirect()
def update_watcher(self, request, watcher):
watcher.email = False
messages.success(
request,
_("You will no longer receive e-mails with notifications when somebody replies to this thread."),
"threads",
)
def post_action_soft(self, ids):
deleted = []
for post in self.posts:
if post.pk in ids and not post.deleted:
if post.pk == self.thread.start_post_id:
raise forms.ValidationError(
_("You cannot delete first post of thread using this action. If you want to delete thread, use thread moderation instead."
))
deleted.append(post.pk)
if deleted:
update_kwargs = {
'deleted': True,
'current_date': timezone.now(),
'delete_date': timezone.now(),
'edit_user': self.request.user,
'edit_user_name': self.request.user.username,
'edit_user_slug': self.request.user.username_slug,
}
self.thread.post_set.filter(id__in=deleted).update(**update_kwargs)
self.thread.sync()
self.thread.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
messages.success(self.request,
_('Selected posts have been hidden.'), 'threads')
else:
messages.info(self.request, _('No posts were hidden.'), 'threads')
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 view(request):
ignored_exclusions = request.session.get("unignore_threads", [])
ignored_exclusions.append(self.thread.pk)
request.session["unignore_threads"] = ignored_exclusions
messages.success(
request, _("Replies made to this thread by members on your ignore list have been revealed."), "threads"
)
return redirect(reverse(self.type_prefix, kwargs={"thread": self.thread.pk, "slug": self.thread.slug}))
def action_hard(self, ids):
if self._action_hard(ids):
messages.success(self.request,
_('Selected threads have been deleted.'),
'threads')
else:
messages.info(self.request, _('No threads were deleted.'),
'threads')
def action_soft(self, ids):
if self._action_soft(ids):
messages.success(self.request,
_('Selected threads have been hidden.'),
'threads')
else:
messages.info(self.request, _('No threads were hidden.'),
'threads')
def action_close(self, ids):
if self._action_close(ids):
messages.success(self.request,
_('Selected threads have been closed.'),
'threads')
else:
messages.info(self.request, _('No threads were closed.'),
'threads')
def update_watcher(self, request, watcher):
watcher.deleted = True
if watcher.pk:
watcher.delete()
if watcher.email:
messages.success(request, _('This thread has been removed from your watched threads list. You will no longer receive e-mails with notifications when somebody replies to it.'), 'threads')
else:
messages.success(request, _('This thread has been removed from your watched threads list.'), 'threads')
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 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 action_accept(self, ids):
if self._action_accept(ids):
messages.success(
self.request,
_('Selected threads have been marked as reviewed and made visible to other members.'
), 'threads')
else:
messages.info(self.request,
_('No threads were marked as reviewed.'), 'threads')
def response(self):
messages.success(self.request, _("Report has been edited."),
'threads_%s' % self.post.pk)
return redirect(
reverse('report',
kwargs={
'thread': self.thread.pk,
'slug': self.thread.slug
}) + ('#post-%s' % self.post.pk))
def action_normal(self, ids):
if self._action_normal(ids):
messages.success(self.request,
_('Selected threads weight has been removed.'),
'threads')
else:
messages.info(self.request,
_('No threads have had their weight removed.'),
'threads')
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 delete_warning(request, user, warning):
request.acl.warnings.allow_delete_warning()
if user.is_warning_active(warning):
alerts.your_warn_has_been_canceled(request.user, user)
user.decrease_warning_level()
warning.delete()
messages.success(request, _("Selected warning has been deleted."))
def action_accept(self, ids):
if self._action_accept(ids):
messages.success(
self.request,
_("Selected threads have been marked as reviewed and made visible to other members."),
"threads",
)
else:
messages.info(self.request, _("No threads were marked as reviewed."), "threads")
def post_action_protect(self, ids):
protected = 0
for post in self.posts:
if post.pk in ids and not post.protected:
protected += 1
if protected:
self.thread.post_set.filter(id__in=ids).update(protected=True)
messages.success(self.request, _("Selected posts have been protected from edition."), "threads")
else:
messages.info(self.request, _("No posts were protected."), "threads")
def post_action_unprotect(self, ids):
unprotected = 0
for post in self.posts:
if post.pk in ids and post.protected:
unprotected += 1
if unprotected:
self.thread.post_set.filter(id__in=ids).update(protected=False)
messages.success(self.request, _('Protection from editions has been removed from selected posts.'), 'threads')
else:
messages.info(self.request, _('No posts were unprotected.'), 'threads')
def action_sticky(self, ids):
if self._action_sticky(ids):
messages.success(
self.request,
_('Selected threads have been sticked to the top of list.'),
'threads')
else:
messages.info(self.request,
_('No threads were turned into stickies.'),
'threads')
def action_annouce(self, ids):
if self._action_annouce(ids):
messages.success(
self.request,
_('Selected threads have been turned into announcements.'),
'threads')
else:
messages.info(self.request,
_('No threads were turned into announcements.'),
'threads')
def edit_promises(request):
if request.method == 'POST':
p_id = request.POST['id']
title = request.POST['title']
text = request.POST['text']
promise = Promise.objects.get(pk=p_id)
promise.title, promise.text = title, text
promise.save()
messages.success(request, ("Proposta alterada!"))
return redirect(reverse('party_promises'))
def response(self):
if self.post.moderated:
messages.success(
self.request,
_("Your reply has been posted. It will be hidden from other members until moderator reviews it."
), 'threads_%s' % self.post.pk)
else:
messages.success(self.request, _("Your reply has been posted."),
'threads_%s' % self.post.pk)
return self.redirect_to_post(self.post)
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 gravatar(request):
if not 'gravatar' in settings.avatars_types:
return error404(request)
if request.user.avatar_type != 'gravatar':
if request.csrf.request_secure(request):
request.user.delete_avatar()
request.user.avatar_type = 'gravatar'
request.user.save(force_update=True)
messages.success(request, _("Your avatar has been changed to Gravatar."), 'usercp_avatar')
else:
messages.error(request, _("Request authorisation is invalid."), 'usercp_avatar')
return redirect(reverse('usercp_avatar'))
def read_all(request):
ForumRead.objects.filter(user=request.user).delete()
ThreadRead.objects.filter(user=request.user).delete()
now = timezone.now()
bulk = []
for forum in request.acl.forums.known_forums():
new_record = ForumRead(user=request.user, forum_id=forum, updated=now, cleared=now)
bulk.append(new_record)
if bulk:
ForumRead.objects.bulk_create(bulk)
messages.success(request, _("All forums have been marked as read."))
return redirect(reverse('index'))
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 update_watcher(self, request, watcher):
watcher.email = True
if watcher.pk:
messages.success(
request,
_('You will now receive e-mail with notification when somebody replies to this thread.'
), 'threads')
else:
messages.success(
request,
_('This thread has been added to your watched threads list. You will also receive e-mail with notification when somebody replies to it.'
), 'threads')
def post_action_accept(self, ids):
accepted = 0
for post in self.posts:
if post.pk in ids and post.moderated:
accepted += 1
if accepted:
self.thread.post_set.filter(id__in=ids).update(moderated=False)
self.thread.sync()
self.thread.save(force_update=True)
messages.success(self.request, _('Selected posts have been accepted and made visible to other members.'), 'threads')
else:
messages.info(self.request, _('No posts were accepted.'), 'threads')
def thread_action_prefix(self, prefix):
try:
prefix = int(prefix)
except TypeError:
prefix = 0
prefix = prefix or None
if prefix:
self._thread_action_set_prefix(self.prefixes[prefix])
messages.success(self.request, _('Threads prefix has been changed to "%(name)s".') % {'name': _(self.prefixes[prefix].name)}, 'threads')
else:
self._thread_action_remove_prefix()
messages.success(self.request, _('Thread prefix has been removed.'), 'threads')
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 post_action_undelete(self, ids):
undeleted = []
for post in self.posts:
if post.pk in ids and post.deleted:
undeleted.append(post.pk)
if undeleted:
self.thread.post_set.filter(id__in=undeleted).update(deleted=False, current_date=timezone.now())
self.thread.sync()
self.thread.save(force_update=True)
self.forum.sync()
self.forum.save(force_update=True)
messages.success(self.request, _("Selected posts have been restored."), "threads")
else:
messages.info(self.request, _("No posts were restored."), "threads")
