def get_absolute_url(self):
target = reverse_lazy('blog:tagged_posts_list', args=[self.slug])
return target
python类reverse_lazy()的实例源码
def password_reset(request):
kwargs = {
'template_name': 'account/password_reset.html',
'success_url': reverse_lazy('account_reset_password_done'),
'email_template_name': 'account/email/password_reset_message.txt',
'subject_template_name': 'account/email/password_reset_subject.txt'}
return django_views.PasswordResetView.as_view(**kwargs)(request, **kwargs)
def password_reset_confirm(request, uidb64=None, token=None):
kwargs = {
'template_name': 'account/password_reset_from_key.html',
'success_url': reverse_lazy('account_reset_password_complete'),
'set_password_form': 'PasswordSetUpForm',
'token': token,
'uidb64': uidb64}
return PasswordResetConfirm.as_view(**kwargs)(
request, **kwargs)
def get_object(self):
host_id = self.kwargs['host_id']
try:
host = api.client.host_get(self.request, host_id)
except Exception:
msg = _("Unable to retrieve host.")
redirect = reverse_lazy('horizon:admin:hosts:index')
exceptions.handle(self.request, msg, redirect=redirect)
return host
def get_api_next_url(self, request, cl):
page_num = cl.page_num
if page_num and page_num is not int or not cl.multi_page:
return None
info = self.model._meta.app_label, self.model._meta.model_name
url = reverse_lazy("admin:%s_%s_api_list" % info)
host = request.get_host()
params = cl.params
params["p"] = page_num + 1
return "%s://%s%s?%s" % (request.scheme, host, url, urlencode(params))
def get_api_previous_url(self, request, cl):
page_num = cl.page_num
if page_num == 0 or not cl.multi_page:
return None
info = self.model._meta.app_label, self.model._meta.model_name
url = reverse_lazy("admin:%s_%s_api_list" % info)
host = request.get_host()
params = cl.params
params["p"] = page_num - 1
return "%s://%s%s?%s" % (request.scheme, host, url, urlencode(params))
def obj_as_dict(self, request, obj):
data = self.serialize_obj(obj)
# serialize model instance fields datas
for field in obj._meta.get_fields():
if field.is_relation and field.concrete:
field_value = getattr(obj, field.name)
if field_value:
if field.many_to_many:
data[field.name] = self.serialize_objs(field_value.all())
elif field.many_to_one or field.one_to_one or field.one_to_many:
data[field.name] = self.serialize_obj(field_value)
# add custom admin class field to serialized bundle
model_admin_fields = self.get_model_admin_field_names(request, obj)
for field in model_admin_fields:
if field in data:
continue
if hasattr(obj, field):
f = getattr(obj, field)
data[field] = unicode(f)
if hasattr(self, field):
field_method = getattr(self, field)
if callable(field_method):
data[field] = field_method(obj)
else:
data[field] = field_method
info = self.model._meta.app_label, self.model._meta.model_name
admin_detail_url = str(reverse_lazy("admin:%s_%s_change" % info, args=(obj.id,)))
data["admin_detail_url"] = admin_detail_url
return data
def delete(self, request, *args, **kwargs):
wishlist = self.get_object()
if wishlist.customer == request.customer:
wishlist.products.remove(self.kwargs['product_pk'])
messages.success(request, _("Product removed from wishlist."))
return HttpResponseRedirect(reverse_lazy('shuup:wishlist_detail', kwargs=dict(pk=wishlist.pk)))
else:
raise Http404
def get_success_url(self, **kwargs):
try:
return reverse_lazy('list_app:item_list',kwargs={'pk':self.kwargs['pk']})
except KeyError:
return reverse_lazy('list_app:list_list')
def get_success_url(self, **kwargs):
return reverse_lazy('list_app:item_list',kwargs={'pk':self.kwargs['pk_list']})
def get_success_url(self, **kwargs):
return reverse_lazy('list_app:item_list',kwargs={'pk':self.kwargs['pk_list']})
def get_redirect_url(self, **kwargs):
try:
item = Item.objects.get(id=self.kwargs['pk'])
item.completed = True
item.save()
return reverse_lazy('list_app:item_list',kwargs={'pk':self.kwargs['pk_list']})
except item.DoesNotExist:
raise Http404
def test_register(self):
""" Register a user acccount. """
response = self.client.post(reverse_lazy('list_app:new_user',
kwargs={'version':'v1'}),
{
"username":"userapi",
"password":"clave"
})
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def get_absolute_url(self):
return reverse_lazy('data-view', {'supportingdata': self.pk})
def process_request(self, request):
try:
display_interval = settings.REQUIRED_INTERSTITIAL_DISPLAY_INTERVAL
except AttributeError:
# Setting not defined, so assume we don't want the interstitial to display
return None
try:
if display_interval == 0 \
and request.session['last_acknowledged_interstitial']:
return None
else:
max_age = timedelta(hours=display_interval).total_seconds()
if timegm(now().timetuple()) - request.session['last_acknowledged_interstitial'] < max_age:
return None
except KeyError:
pass
path = request.get_full_path()
if re.match(str(reverse_lazy('login-interstitial')), path) or \
re.match(str(reverse_lazy('login')), path) or \
re.match(str(reverse_lazy('logout')), path) or \
re.match(settings.STATIC_URL + r'.+', path):
return None
return redirect('login-interstitial')
def get_context_data(self, **kwargs):
"""Return context for template."""
context = super(NetworksView, self).get_context_data(**kwargs)
context['table'] = {
'name': 'networks',
'title': 'Peering Networks',
'api': {
'definition': reverse_lazy('networkproxy-tabledef'),
'data': reverse_lazy('networkproxy-datatable')
}
}
return context
def get_context_data(self, **kwargs):
"""Return context for template."""
context = super(InternetExchangeView, self).get_context_data(**kwargs)
context['table'] = {
'name': 'ixps',
'title': 'Internet Exchange Points',
'api': {
'definition': reverse_lazy('internetexchangeproxy-tabledef'),
'data': reverse_lazy('internetexchangeproxy-datatable')
}
}
return context
def get_context_data(self, **kwargs):
"""Return context for template."""
context = super(PeeringSessionsView, self).get_context_data(**kwargs)
context['table'] = {
'name': 'sessions',
'title': 'Peering Sessions',
'api': {
'definition': reverse_lazy('peeringsession-tabledef'),
'data': reverse_lazy('peeringsession-datatable')
}
}
return context
def get_context_data(self, **kwargs):
"""Return context for template."""
context = super(PeeringRoutersView, self).get_context_data(**kwargs)
context['table'] = {
'name': 'routers',
'title': 'Peering Routers',
'api': {
'definition': reverse_lazy('peeringrouter-tabledef'),
'data': reverse_lazy('peeringrouter-datatable')
}
}
return context
def post(self, request):
produto_id = request.POST.get('produto_id')
produto = Produto.objects.get(id=produto_id)
carrinho, _ = Carrinho.objects.get_or_create(usuario=request.user, aberto=True)
carrinho.produtos.add(produto)
carrinho.save()
return HttpResponseRedirect(reverse_lazy('carrinho'))
