I am working on a simple project on Django. Currently the views that I am implementing always return a hardcode path:
def temp_view(request):
...
return render("app/detail.html")
or
def temp_view_2(request):
...
return redirect("/app/view2")
What I want to do is to get rid of the hardcode URL (for view URL and the template URL). Is there a proper way to do that?
Thanks.
Django provides a few different methods. In a view, the django.core.urlresolvers.reverse() function is most often used. A full discussion of this problem and the options provided by Django is here:
https://docs.djangoproject.com/en/dev/topics/http/urls/#reverse-resolution-of-urls
Related
I have two Django views that render two separate templates. Each of these templates will contain a link to the same third view.
That third view will render a template that should display one button if the first Django view/template link redirected to it but render a different button if the second view/template link redirected to it.
The URI for the link in each of these templates will be something like this:
/members/near/<from_uid>/profile/<to_uid>/
What is the most robust or "best-practice" way to tell the third view who called it? Should I create links like the following?
/members/near/<from_uid>/profile/<to_uid>/from/<view_name>
/members/near/<from_uid>/profile/<to_uid>/from/<view_name>
Would it be better to examine the HTTP referer header field in the request? Or is there some other better technique for doing this?
By the way, I realize my URI isn't RESTful but I don't feel that I understand REST sufficiently well to create RESTful URIs, particularly when I have to pass multiple arguments as I do here with the from_uid and to_uid arguments.
Thanks!
You can have a part of the URL to be used as a parameters. Each parameter will be set based on the regex provided. an example here. One view can handle all your urls that contain the three parameters you mentioned.
url(r'^members/near/(?P<from_uid>\d+)/profile/(?P<to_uid>\d+)/from//(?P<view_name>\W+)/$', MyView.as_view(), name = 'my_named_view')
Then in your view you just pull these parameters from the url
from_uid = self.kwargs['from_uid']
to_uid = self.kwargs['to_uid']
view_name = self.kwargs['view_name']
if view_name == "....":
# render to template1
elif view_name == "....":
# render to template2
Use GET parameters like this...
Template 1:
Link
Template 2:
Link
And in your third view...
from_view = self.request.GET.pop('from')
if from_view == 'view1':
...
elif from_view == 'view2':
...
GET parameters are more appropriate than URL-captured parameters in a situation like this.
I did pagination in my django projet. Everything works just perfect, but my urls looks terrible, like
host:8000/?page=1
How to create nice urls like
host:8000/page/2/ or host:8000/2/
I use standard Paginator class via ListView
How to do this w/o third party code ?
If you define url pattern like this:
url(r'^/page/(?P<page>\d+)/$', 'myapp.views.list_view'),
then ListView will pass page url keyword into paginator.
Notice:
Each path segment is supposed to be a valid resource, so it's not clear what you will display on /path/ URL.
Django pagination system assumes that webpages will default to using the URL query, so it's recommended to keep it as a URL query and it's more revealing.
When I read Django code sometimes, I see in some templates reverse(). I am not quite sure what this is but it is used together with HttpResponseRedirect. How and when is this reverse() supposed to be used?
reverse() | Django documentation
Let's suppose that in your urls.py you have defined this:
url(r'^foo$', some_view, name='url_name'),
In a template you can then refer to this url as:
<!-- django <= 1.4 -->
link which calls some_view
<!-- django >= 1.5 or with {% load url from future %} in your template -->
link which calls some_view
This will be rendered as:
link which calls some_view
Now say you want to do something similar in your views.py - e.g. you are handling some other URL (not /foo/) in some other view (not some_view) and you want to redirect the user to /foo/ (often the case on successful form submission).
You could just do:
return HttpResponseRedirect('/foo/')
But what if you want to change the URL in the future? You'd have to update your urls.py and all references to it in your code. This violates the DRY (Don't Repeat Yourself) principle and the whole idea of editing in one place only - which is something to strive for.
Instead, you can say:
from django.http import HttpResponseRedirect
from django.urls import reverse
return HttpResponseRedirect(reverse('url_name'))
This looks through all URLs defined in your project for the URL defined with the name url_name and returns the actual URL /foo/.
This means that you refer to the URL only by its name attribute - if you want to change the URL itself or the view it refers to you can do this by editing one place only - urls.py.
The existing answers are quite clear. Just in case you do not know why it is called reverse: It takes an input of a url name and gives the actual url, which is reverse to having a url first and then give it a name.
Existing answers did a great job at explaining the what of this reverse() function in Django.
However, I'd hoped that my answer shed a different light at the why: why use reverse() in place of other more straightforward, arguably more pythonic approaches in template-view binding, and what are some legitimate reasons for the popularity of this "redirect via reverse() pattern" in Django routing logic.
One key benefit is the reverse construction of a url, as others have mentioned. Just like how you would use {% url "profile" profile.id %} to generate the url from your app's url configuration file: e.g. path('<int:profile.id>/profile', views.profile, name="profile").
But as the OP have noted, the use of reverse() is also commonly combined with the use of HttpResponseRedirect. But why?
I am not quite sure what this is but it is used together with HttpResponseRedirect. How and when is this reverse() supposed to be used?
Consider the following views.py:
from django.http import HttpResponseRedirect
from django.urls import reverse
def vote(request, question_id):
question = get_object_or_404(Question, pk=question_id)
try:
selected = question.choice_set.get(pk=request.POST['choice'])
except KeyError:
# handle exception
pass
else:
selected.votes += 1
selected.save()
return HttpResponseRedirect(reverse('polls:polls-results',
args=(question.id)
))
And our minimal urls.py:
from django.urls import path
from . import views
app_name = 'polls'
urlpatterns = [
path('<int:question_id>/results/', views.results, name='polls-results'),
path('<int:question_id>/vote/', views.vote, name='polls-vote')
]
In the vote() function, the code in our else block uses reverse along with HttpResponseRedirect in the following pattern:
HttpResponseRedirect(reverse('polls:polls-results',
args=(question.id)
This first and foremost, means we don't have to hardcode the URL (consistent with the DRY principle) but more crucially, reverse() provides an elegant way to construct URL strings by handling values unpacked from the arguments (args=(question.id) is handled by URLConfig). Supposed question has an attribute id which contains the value 5, the URL constructed from the reverse() would then be:
'/polls/5/results/'
In normal template-view binding code, we use HttpResponse() or render() as they typically involve less abstraction: one view function returning one template:
def index(request):
return render(request, 'polls/index.html')
But in many legitimate cases of redirection, we typically care about constructing the URL from a list of parameters. These include cases such as:
HTML form submission through POST request
User login post-validation
Reset password through JSON web tokens
Most of these involve some form of redirection, and a URL constructed through a set of parameters. Hope this adds to the already helpful thread of answers!
This is an old question, but here is something that might help someone.
From the official docs:
Django provides tools for performing URL reversing that match the
different layers where URLs are needed: In templates: Using the url
template tag. In Python code: Using the reverse() function. In higher
level code related to handling of URLs of Django model instances: The
get_absolute_url() method.
Eg. in templates (url tag)
2012 Archive
Eg. in python code (using the reverse function)
return HttpResponseRedirect(reverse('news-year-archive', args=(year,)))
The function supports the dry principle - ensuring that you don't hard code urls throughout your app. A url should be defined in one place, and only one place - your url conf. After that you're really just referencing that info.
Use reverse() to give you the url of a page, given either the path to the view, or the page_name parameter from your url conf. You would use it in cases where it doesn't make sense to do it in the template with {% url 'my-page' %}.
There are lots of possible places you might use this functionality. One place I've found I use it is when redirecting users in a view (often after the successful processing of a form)-
return HttpResponseRedirect(reverse('thanks-we-got-your-form-page'))
You might also use it when writing template tags.
Another time I used reverse() was with model inheritance. I had a ListView on a parent model, but wanted to get from any one of those parent objects to the DetailView of it's associated child object. I attached a get__child_url() function to the parent which identified the existence of a child and returned the url of it's DetailView using reverse().
There is a doc for that
https://docs.djangoproject.com/en/dev/topics/http/urls/#reverse-resolution-of-urls
it can be used to generate an URL for a given view
main advantage is that you do not hard code routes in your code.
The reverse() is used to adhere the django DRY principle i.e if you change the url in future then you can reference that url using reverse(urlname).
I'd like to use url arguments in views (not templates, I know how to do that).
So is it possible to use them like:
def item_link(self, item):
return mainpage_url_name + "%s/%i" % (item.slug, item.cid)
mainpage_url_name - is of course defined in url patterns (as name variable)
I'm a total newb in Django...
Thanks
First you should use names for your url patterns as documented here.
Then you can use reverse() to use these names in your views or methods.
Following your comments you are using the syndication framework.
Therefore you should make sure that you define get_absolute_url() for you models, ideally using the permalink decorator (for a clean reversing of your urls).
Looking at the example from Django's docs that should be all that's necessary.
To specify the contents of <link>, you
have two options. For each item in
items(), Django first tries calling
the item_link() method on the Feed
class. In a similar way to the title
and description, it is passed it a
single parameter, item. If that method
doesn't exist, Django tries executing
a get_absolute_url() method on that
object.
I'd like to integrate django Databrowse into my application.
It comes down to pointing to databrowse urls from within template or view for enhanced drill down functionality of the databrowse.
Is there an easy way to extract the url from a databrowse object?
Well, one easy way would be to just construct the url you want, and pass it into the template:
databrowse_url = '/'.join((obj._meta.app_label, obj._meta.module_name, 'objects', str(obj.id)))
And then in the template (assuming you have databrowse situated at /databrowse:
<a href="/databrowse/{{ databrowse_url }}">
Which would give you a url like: /databrowse/app_name/model_name/objects/1.
You could recreate the databrowse urls in the format thats show in the databrowse urls.py
You might be able to get the url tag to work in your template by passing the view name + arguments.
However, if you browse the source, it looks like databrowse will add a 'url' attribute to the objects it works with.
EDIT:
Given an EasyModel instance, you can do the following:
my_easy_model_instance.url()
Most of the 'Easy' classes have a url() or urls() method on them.
Ended up writing mixin class that fetches relevant EasyInstance and reuses the url() of it:
from django.contrib.databrowse.datastructures import EasyModel
from django.contrib.databrowse import site
class DatabrowseMixin:
def url(pyClass):
if not site.root_url:
#hack, but root_url is not set until the first databrowse view
#and resolving urlconf does not work either
site.root_url = '/databrowse/'
easy_model = EasyModel(site, pyClass.__class__)
obj = easy_model.object_by_pk(pyClass.pk)
return obj.url()
class MyModel(models.Model, DatabrowseMixin):
...
Now in my templates I can reuse my_model_instance.url tag pointing to databrowse object url.