def proposal_leave(request, pk):
queryset = ProposalBase.objects.select_related("speaker")
proposal = get_object_or_404(queryset, pk=pk)
proposal = ProposalBase.objects.get_subclass(pk=proposal.pk)
try:
speaker = proposal.additional_speakers.get(user=request.user)
except ObjectDoesNotExist:
return HttpResponseForbidden()
if request.method == "POST":
proposal.additional_speakers.remove(speaker)
# @@@ fire off email to submitter and other speakers
messages.success(request, "You are no longer speaking on %s" % proposal.title)
return redirect("dashboard")
ctx = {
"proposal": proposal,
}
return render(request, "proposals/proposal_leave.html", ctx)
python类success()的实例源码
def post_model_create_view(request):
form = PostModelForm(request.POST or None)
context = {
"form": form
}
if form.is_valid():
obj = form.save(commit=False)
#print(obj.title)
obj.save()
messages.success(request, "Created a new blog post!")
context = {
"form": PostModelForm()
}
#return HttpResponseRedirect("/blog/{num}".format(num=obj.id))
template = "blog/create-view.html"
return render(request, template, context)
#@login_required
def scan_scan_list(request: HttpRequest, scan_list_id: int) -> HttpResponse:
"""Schedule the scan of a scan list."""
scan_list = get_object_or_404(
ScanList.objects.prefetch_related(Prefetch(
'sites',
queryset=Site.objects.select_related('last_scan') \
.annotate_most_recent_scan_start() \
.annotate_most_recent_scan_end_or_null())
), pk=scan_list_id)
was_any_site_scannable = scan_list.scan()
if was_any_site_scannable:
num_scanning_sites = Scan.objects.filter(end__isnull=True).count()
messages.success(request,
_("Scans for this list have been scheduled. "+ \
"The total number of sites in the scanning queue "+ \
"is %i (including yours)." % num_scanning_sites))
else:
messages.warning(request,
_('All sites have been scanned recently. Please wait 30 minutes and try again.'))
return redirect(reverse('frontend:view_scan_list', args=(scan_list_id,)))
def remove(request, device_id):
device_qs = (
twofa.models.Device.objects
.active_for_user(request.user).select_subclasses())
device = get_object_or_404(device_qs, pk=device_id)
if not device.can_delete():
messages.error(
request, _('The "%(auth_name)s" authenticator cannot be removed.') % {'auth_name': device.name()})
return redirect('twofa:list')
device.deleted_at = timezone.now()
device.save()
messages.success(
request, _('The "%(auth_name)s" authenticator has been removed from your account.') % {
'auth_name': device.name()})
if not twofa.models.Device.objects.active_for_user(request.user).exclude_backup().exists():
request.user.twofa_enabled = False
request.user.save()
messages.info(
request, _('Since you removed the last authenticator from your account, '
'two-factor authentication has now been disabled.'))
return redirect('twofa:list')
def verify_step2(request, uidb64, token):
bytes_uid = urlsafe_base64_decode(uidb64)
try:
uid = int(bytes_uid)
except ValueError:
raise SuspiciousOperation('verify_step2 received invalid base64 user ID: {}'.format(
bytes_uid))
if uid != request.user.id:
raise PermissionDenied('UID mismatch - user is {}, request was for {}'.format(
request.user.id, uid))
user = get_object_or_404(models.User, pk=uid)
if not verify_token_generator.check_token(user, token):
raise Http404('token invalid')
if not user.email_verified:
user.email_verified = True
user.save()
messages.success(request, _('Your email has been verified successfully. Thanks!'))
else:
messages.info(request, _('Your email address has already been verified.'))
return redirect('index')
def post(self, request):
target = request.POST.get('target')
pk = request.POST.get('user')
user = User.objects.get(pk=pk)
if 'troubleshooter' in target:
user.is_troubleshooter = target[-1] == 'y'
elif 'backoffice' in target:
user.is_backoffice_user = target[-1] == 'y'
elif 'superuser' in target:
user.is_superuser = target[-1] == 'y'
user.save()
if target[-1] == 'y':
messages.success(request, _('User rights have been expanded'))
else:
messages.success(request, _('User rights have been curtailed.'))
return redirect('backoffice:wizard-users')
def reverse_session_view(request: HttpRequest, pk: int) -> Union[HttpRequest, HttpResponseRedirect]:
session = get_object_or_404(CashdeskSession, pk=pk)
if request.method == 'POST':
try:
reverse_session(session)
except FlowError as e:
messages.error(request, str(e))
else:
messages.success(request, _('All transactions in the session have been cancelled.'))
return redirect('backoffice:session-detail', pk=pk)
elif request.method == 'GET':
return render(request, 'backoffice/reverse_session.html', {
'session': session,
})
def add_slack_btn(request):
code = request.GET.get("code", "")
if len(code) < 8:
return HttpResponseBadRequest()
result = requests.post("https://slack.com/api/oauth.access", {
"client_id": settings.SLACK_CLIENT_ID,
"client_secret": settings.SLACK_CLIENT_SECRET,
"code": code
})
doc = result.json()
if doc.get("ok"):
channel = Channel()
channel.user = request.team.user
channel.kind = "slack"
channel.value = result.text
channel.save()
channel.assign_all_checks()
messages.success(request, "The Slack integration has been added!")
else:
s = doc.get("error")
messages.warning(request, "Error message from slack: %s" % s)
return redirect("hc-channels")
def set_password(request, token):
profile = request.user.profile
if not check_password(token, profile.token):
return HttpResponseBadRequest()
if request.method == "POST":
form = SetPasswordForm(request.POST)
if form.is_valid():
password = form.cleaned_data["password"]
request.user.set_password(password)
request.user.save()
profile.token = ""
profile.save()
# Setting a password logs the user out, so here we
# log them back in.
u = authenticate(username=request.user.email, password=password)
auth_login(request, u)
messages.success(request, "Your password has been set!")
return redirect("hc-profile")
return render(request, "accounts/set_password.html", {})
def change_password(request):
if request.method == 'POST':
user = request.user
old_password = request.POST.get('old_password')
new_password = request.POST.get('new_password')
confirm_password = request.POST.get('confirm_password')
if authenticate(username=user.username, password=old_password):
if new_password == confirm_password:
user.set_password(new_password)
user.save()
messages.success(request, 'Password Updated')
else:
messages.warning(request, 'Passwords do not match')
else:
messages.warning(request, 'Invalid Password')
return render(request,
'taskManager/change_password.html',
{'user': request.user})
def post(self, request, *args, **kwargs):
ids = request.POST.getlist('selected')
apps = models.Application.objects.filter(pk__in=ids).all()
mails = []
errors = 0
for app in apps:
try:
app.invite(request.user)
m = emails.create_invite_email(app, request)
mails.append(m)
except ValidationError:
errors += 1
if mails:
send_batch_emails(mails)
messages.success(request, "%s applications invited" % len(mails))
else:
messages.error(request, "%s applications not invited" % errors)
return HttpResponseRedirect(reverse('invite_list'))
def post(self, request, *args, **kwargs):
try:
form = forms.ReceiptSubmissionReceipt(request.POST, request.FILES, instance=request.user.reimbursement)
except:
form = forms.ReceiptSubmissionReceipt(request.POST, request.FILES)
if form.is_valid():
reimb = form.save(commit=False)
reimb.hacker = request.user
reimb.save()
messages.success(request,
'We have now received your reimbursement. '
'Processing will take some time, so please be patient.')
return HttpResponseRedirect(reverse('reimbursement_dashboard'))
else:
c = self.get_context_data()
c.update({'form': form})
return render(request, self.template_name, c)
def post(self, request, *args, **kwargs):
ids = request.POST.getlist('selected')
reimbs = models.Reimbursement.objects.filter(pk__in=ids).all()
mails = []
errors = 0
for reimb in reimbs:
try:
assigned_money = request.POST.get('am_' + str(reimb.pk))
reimb.assigned_money = assigned_money
reimb.send(request.user)
m = emails.create_reimbursement_email(reimb, request)
mails.append(m)
except ValidationError:
errors += 1
if mails:
send_batch_emails(mails)
messages.success(request, "%s reimbursements sent" % len(mails))
else:
messages.error(request, "%s reimbursements not sent" % errors)
return HttpResponseRedirect(reverse('send_reimbursement'))
def activate(request, uid, token):
try:
uid = force_text(urlsafe_base64_decode(uid))
user = User.objects.get(pk=uid)
if request.user != user:
messages.warning(request, "User email can be verified")
return redirect('root')
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
messages.warning(request, "User email can be verified")
return redirect('root')
if account_activation_token.check_token(user, token):
messages.success(request, "Email verified!")
user.email_verified = True
user.save()
auth.login(request, user)
else:
messages.error(request, "This email verification url has expired")
return redirect('root')
def post(self, request, *args, **kwargs):
new_application = True
try:
form = forms.ApplicationForm(request.POST, request.FILES, instance=request.user.application)
new_application = False
except:
form = forms.ApplicationForm(request.POST, request.FILES)
if form.is_valid():
application = form.save(commit=False)
application.user = request.user
application.save()
if new_application:
messages.success(request,
'We have now received your application. '
'Processing your application will take some time, so please be patient.')
else:
messages.success(request, 'Application changes saved successfully!')
return HttpResponseRedirect(reverse('root'))
else:
c = self.get_context_data()
c.update({'form': form})
return render(request, self.template_name, c)
def ArticleEdit(request):
if request.method == "POST":
ueditorform = UEditorForm(request.POST)
user = request.user
if ueditorform.is_valid():
article = Article.objects.create(author_id=user.pk,
category_id=ueditorform.clean()['category'],
title=ueditorform.clean()['title'],
article_from=ueditorform.clean()['article_from'],
summary=ueditorform.clean()['summary'],
tags=ueditorform.clean()['tags'],
content=ueditorform.clean()['content'],
)
if article is not None:
user.topic_num += 1
user.save()
messages.success(request, '?????????????')
return HttpResponseRedirect(reverse('index-view'))
else:
ueditorform = UEditorForm()
return render(request,'blog/article_edit.html',{'form': ueditorform})
def password(request):
user = request.user
if request.method == "POST":
form = PasswordChangeForm(request.POST)
if form.is_valid():
data = form.clean()
if user.check_password(data["old_password"]):
user.set_password(data["password"])
user.save()
messages.success(request, "?????????????")
auth_logout(request)
return HttpResponseRedirect(reverse("login"))
else:
messages.error(request,'????????')
return render(request, "users/password.html", {'errors': form.errors})
else:
form = PasswordChangeForm()
return render(request, "users/password.html")
def form_valid(self, form):
form.instance.remote_address = self.request.META.get(
'HTTP_X_REAL_IP', '0.0.0.0'
)
try:
self.object = form.save()
form.send_email(request=self.request)
except: # pragma: no cover
messages.error(self.request,
'An internal server error occured.',
extra_tags='form_invalid',
)
else:
messages.success(self.request,
'Thanks! Someone will contact you soon.',
extra_tags='form_valid',
)
return super(ContactView, self).form_valid(form)
def create_person_patch(request, jur_id):
if request.method == 'POST':
p = Person.objects.get(id=request.POST['person'])
# if any error occur then `create` will throw error.
IssueResolverPatch.objects.create(
content_object=p,
jurisdiction_id=jur_id,
status='unreviewed',
old_value=request.POST['old_value'],
new_value=request.POST['new_value'],
source=request.POST.get('source'),
category=request.POST['category'],
alert='error',
note=request.POST.get('note'),
applied_by='admin',
)
messages.success(request, "Successfully created Patch")
people = Person.objects.filter(
memberships__organization__jurisdiction_id=jur_id).distinct()
context = {'jur_id': jur_id,
'people': people}
return render(request, 'admintools/create_person_patch.html', context)
# Data Quality Exceptions
def form_valid(self, form):
"""Posts entitlement data to API"""
try:
data = form.cleaned_data
urlpath = '/users/{}/entitlements'.format(data['user_id'])
payload = {
'bank_id': data['bank_id'],
'role_name': data['role_name'],
}
entitlement = self.api.post(urlpath, payload=payload)
except APIError as err:
messages.error(self.request, err)
return super(DetailView, self).form_invalid(form)
msg = 'Entitlement with role {} has been added.'.format(
entitlement['role_name'])
messages.success(self.request, msg)
self.success_url = self.request.path
return super(DetailView, self).form_valid(form)
