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")