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'))
python类error()的实例源码
def signup(request):
# if this is a POST request we need to process the form data
if request.method == 'POST':
form = forms.RegisterForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
password = form.cleaned_data['password']
name = form.cleaned_data['name']
if models.User.objects.filter(email=email).first() is not None:
messages.error(request, 'An account with this email already exists')
else:
user = models.User.objects.create_user(email=email, password=password, name=name)
user = auth.authenticate(email=email, password=password)
auth.login(request, user)
return HttpResponseRedirect(reverse('root'))
else:
form = forms.RegisterForm()
return render(request, 'signup.html', {'form': form})
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 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 get_context_data(self, **kwargs):
context = super(IndexView, self).get_context_data(**kwargs)
consumers = []
api = API(self.request.session.get('obp'))
try:
urlpath = '/management/consumers'
consumers = api.get(urlpath)
consumers = FilterEnabled(context, self.request.GET)\
.apply(consumers['list'])
consumers = FilterAppType(context, self.request.GET)\
.apply(consumers)
consumers = FilterTime(context, self.request.GET, 'created')\
.apply(consumers)
consumers = self.scrub(consumers)
except APIError as err:
messages.error(self.request, err)
sorted_consumers = sorted(
consumers, key=lambda consumer: consumer['created'], reverse=True)
context.update({
'consumers': sorted_consumers,
'statistics': self.compile_statistics(consumers),
})
return context
def get_context_data(self, **kwargs):
context = super(DetailView, self).get_context_data(**kwargs)
api = API(self.request.session.get('obp'))
try:
urlpath = '/management/consumers/{}'.format(kwargs['consumer_id'])
consumer = api.get(urlpath)
consumer['created'] = datetime.strptime(
consumer['created'], settings.API_DATETIMEFORMAT)
except APIError as err:
messages.error(self.request, err)
context.update({
'consumer': consumer,
})
return context
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)
def get_context_data(self, **kwargs):
context = super(DetailView, self).get_context_data(**kwargs)
# NOTE: assuming there is just one user with that email address
# The API needs a call 'get user by id'!
user = {}
try:
urlpath = '/users/user_id/{}'.format(self.kwargs['user_id'])
user = self.api.get(urlpath)
context['form'].fields['user_id'].initial = user['user_id']
except APIError as err:
messages.error(self.request, err)
context.update({
'apiuser': user, # 'user' is logged-in user in template context
})
return context
def get_redirect_url(self, *args, **kwargs):
callback_uri = self.get_callback_uri(self.request)
try:
authenticator = OAuthAuthenticator()
authorization_url = authenticator.get_authorization_url(
callback_uri)
except AuthenticatorError as err:
messages.error(self.request, err)
return reverse('home')
else:
self.request.session['obp'] = {
'authenticator': 'obp.oauth.OAuthAuthenticator',
'authenticator_kwargs': {
'token': authenticator.token,
'secret': authenticator.secret,
}
}
return authorization_url
def get_redirect_url(self, *args, **kwargs):
session_data = self.request.session.get('obp')
authenticator_kwargs = session_data.get('authenticator_kwargs')
authenticator = OAuthAuthenticator(**authenticator_kwargs)
authorization_url = self.request.build_absolute_uri()
try:
authenticator.set_access_token(authorization_url)
except AuthenticatorError as err:
messages.error(self.request, err)
else:
session_data['authenticator_kwargs'] = {
'token': authenticator.token,
'secret': authenticator.secret,
}
self.login_to_django()
messages.success(self.request, 'OAuth login successful!')
redirect_url = self.request.GET.get('next', reverse('home'))
return redirect_url
def import_corpus_view(request):
if request.method == 'POST':
corpus_id = request.POST.get('corpus_id', None)
success = False
corpus = Corpus.objects.get(pk=corpus_id)
if corpus.status == 'NI':
t = import_corpus_task.delay(corpus.pk)
corpus.status = 'IR'
corpus.current_task_id = t.task_id
corpus.save()
success = True
if success:
messages.success(request, "The {} corpus import was started successfully!".format(corpus.name))
else:
messages.error(request, "Something went wrong!")
return redirect('pgdb:corpus_status')
def change_database_status(request):
if request.method == 'POST':
database = request.POST.get('database', None)
action = request.POST.get('action', None)
if database is not None:
db = Database.objects.get(name=database)
if action == 'stop':
mod_action = 'stopped'
success = db.stop()
elif action == 'start':
mod_action = 'started'
success = db.start()
else: # FIXME for downloading logs
success = False
pass
if action != 'log':
if success:
messages.success(request, "The database {} was successfully {}!".format(db.name, mod_action))
else:
messages.error(request,
"The database {} could not be {}. Please check the relevant logs.".format(db.name,
mod_action))
return redirect('pgdb:database_status')
def get_corpus_status(request, name=None):
if request.method == 'GET':
try:
corpus = Corpus.objects.get(name=name)
except ObjectDoesNotExist:
return HttpResponse('Could not find the specified corpus.', status=status.HTTP_404_NOT_FOUND)
if corpus.current_task_id is None:
return JsonResponse(data={'data': 'ready'}, status=status.HTTP_200_OK)
else:
res = AsyncResult(corpus.current_task_id)
if res.state == cstates.SUCCESS:
corpus.current_task_id = None
if corpus.status == Corpus.IMPORT_RUNNING:
corpus.status = Corpus.IMPORTED
corpus.save()
return JsonResponse(data={'data': 'ready'}, status=status.HTTP_200_OK)
elif res.state == cstates.FAILURE:
corpus.current_task_id = None
if corpus.status == Corpus.IMPORT_RUNNING:
corpus.status = Corpus.NOT_IMPORTED
corpus.save()
return JsonResponse(data={'data': 'error'}, status=status.HTTP_200_OK)
return JsonResponse(data={'data': 'busy'}, status=status.HTTP_200_OK)
def success_view(self, request):
try:
self._process_query(request.GET.copy(), request)
except ValidationError as exc:
mail_managers(
'Validation error in PostFinance success view',
'\n'.join([
request.build_absolute_uri(),
'',
] + [m for m in exc.messages]),
)
for m in exc.messages:
messages.error(request, m)
return redirect(self.failure_url)
else:
return redirect(self.success_url)
def check_webhooks(request):
user = request.user
if not hasattr(user, 'wunderlist'):
return render(request, 'wunderlist/check_webhooks.html')
api = WunderlistApi(user.wunderlist.api_token)
lists = api.get_lists()
if lists is None:
messages.error(request, _('Could not get lists from Wunderlist. Please try to reconnect.'))
return redirect('index')
webhooks = []
for l in lists:
webhooks.extend(api.get_webhooks(l[default.JSON_ID]))
return render(request, 'wunderlist/check_webhooks.html', {'lists': lists, 'webhooks': webhooks})
def manage_auth_already_associated(backend, uid, user=None, *args, **kwargs):
""" OVERRIDED: It will logout the current user
instead of raise an exception
Fix to resolve AuthAlreadyAssociated Exception in Python Social Auth:
http://stackoverflow.com/questions/13018147/authalreadyassociated-exception-in-django-social-auth
"""
provider = backend.name
social = backend.strategy.storage.user.get_social_auth(provider, uid)
if social:
if user and social.user != user:
messages.error(backend.strategy.request, _('This account is already in use.'))
return HttpResponseRedirect(reverse('home'))
# msg = 'This {0} account is already in use.'.format(provider)
# raise AuthAlreadyAssociated(backend, msg)
elif not user:
user = social.user
return {'social': social,
'user': user,
'is_new': user is None,
'new_association': False}
def login_mio(request):
if request.method == "POST":
username = request.POST['username']
password = request.POST['password']
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
return redirect ('select_perfil')
else:
messages.error(request, "Usuario y/o contraseña incorrectos.")
return render(request, 'accounts/login.html')
else:
return render(request, 'accounts/login.html')
#seleccionar perfil una vez logueado
def password(request):
previous_page = settings.BASE_URL
if request.user.has_usable_password():
PasswordForm = PasswordChangeForm
else:
PasswordForm = AdminPasswordChangeForm
if request.method == 'POST':
form = PasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
update_session_auth_hash(request, form.user)
messages.success(request, 'Your password was successfully updated!')
#return redirect('password')
return render(request, 'registration/password_thanks.html', {'form': form, 'previous_page': previous_page } )
else:
messages.error(request, 'Please correct the error below.')
else:
form = PasswordForm(request.user)
return render(request, 'registration/password.html', {'form': form } )
