Comment puis-je obtenir l'URL complète / absolue (par exemple https://example.com/some/path) dans Django sans le module Sites ? C'est juste idiot ... Je ne devrais pas avoir besoin d'interroger ma base de données pour accrocher l'URL!

Je veux l'utiliser avec reverse().

Utilisez la méthode request.build_absolute_uri () pratique sur demande, passez-lui l'URL relative et elle vous en donnera une complète.

Par défaut, l'URL absolue de request.get_full_path()est renvoyée, mais vous pouvez lui passer une URL relative comme premier argument pour la convertir en URL absolue.

Si vous souhaitez l'utiliser avec reverse()vous pouvez le faire:request.build_absolute_uri(reverse('view_name', args=(obj.pk, )))

Vous pouvez également l'utiliser get_current_sitedans le cadre de l'application sites ( from django.contrib.sites.models import get_current_site). Il prend un objet de demande et prend par défaut l'objet de site avec lequel vous avez configuré SITE_IDdans settings.py si la demande l'est None. En savoir plus dans la documentation pour utiliser le framework de sites

par exemple

from django.contrib.sites.shortcuts import get_current_site
request = None
full_url = ''.join(['http://', get_current_site(request).domain, obj.get_absolute_url()])

Il n'est pas aussi compact / soigné que request.build_absolute_url(), mais il est utilisable lorsque les objets de demande ne sont pas disponibles et que vous avez une URL de site par défaut.

Si vous ne pouvez pas y accéder, requestvous ne pouvez pas l'utiliser get_current_site(request)comme recommandé dans certaines solutions ici. Vous pouvez utiliser une combinaison du framework Sites natif et à la get_absolute_urlplace. Configurez au moins un site dans l'administrateur, assurez-vous que votre modèle dispose d'une méthode get_absolute_url () , puis:

>>> from django.contrib.sites.models import Site
>>> domain = Site.objects.get_current().domain
>>> obj = MyModel.objects.get(id=3)
>>> path = obj.get_absolute_url()

>>> url = 'http://{domain}{path}'.format(domain=domain, path=path)
>>> print(url)
'http://example.com/mymodel/objects/3/'

https://docs.djangoproject.com/en/dev/ref/contrib/sites/#getting-the-current-domain-for-full-urls

Si vous ne voulez pas accéder à la base de données, vous pouvez le faire avec un paramètre. Ensuite, utilisez un processeur de contexte pour l'ajouter à chaque modèle:

# settings.py (Django < 1.9)
...
BASE_URL = 'http://example.com'
TEMPLATE_CONTEXT_PROCESSORS = (
    ...
    'myapp.context_processors.extra_context',
)
# settings.py (Django >= 1.9)
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                # Additional
                'myapp.context_processors.extra_context',
            ],
        },
    },
]

# myapp/context_processors.py
from django.conf import settings

def extra_context(request):
    return {'base_url': settings.BASE_URL}

# my_template.html
<p>Base url is {{ base_url }}.</p>

À votre avis, procédez comme suit:

base_url =  "{0}://{1}{2}".format(request.scheme, request.get_host(), request.path)

django-fullurl

Si vous essayez de le faire dans un modèle Django, j'ai publié un petit paquet PyPI django-fullurlpour vous permettre de remplacer urlet de staticbalises de modèle avec fullurlet fullstatic, comme ceci:

{% load fullurl %}

Absolute URL is: {% fullurl "foo:bar" %}

Another absolute URL is: {% fullstatic "kitten.jpg" %}

Nous espérons que ces badges resteront à jour automatiquement:

Dans une vue, vous pouvez bien sûr utiliser à la request.build_absolute_uriplace.

Pour créer un lien complet vers une autre page à partir d'un modèle, vous pouvez utiliser ceci:

{{ request.META.HTTP_HOST }}{% url 'views.my_view' my_arg %}

request.META.HTTP_HOST donne le nom d'hôte et url le nom relatif. Le moteur de modèle les concatène ensuite en une URL complète.

Encore une autre façon. Vous pouvez l'utiliser build_absolute_uri()dans votre view.pyet le transmettre au modèle.

view.py

def index(request):
    baseurl = request.build_absolute_uri()
    return render_to_response('your-template.html', { 'baseurl': baseurl })

votre-template.html

{{ baseurl }}

Examinez le Request.METAdictionnaire qui entre. Je pense qu'il a un nom de serveur et un port de serveur.

Essayez le code suivant:

{{ request.scheme }}://{{ request.META.HTTP_HOST }}

Cela a fonctionné pour moi dans mon modèle:

{{ request.scheme }}:{{ request.META.HTTP_HOST }}{% url  'equipos:marca_filter' %}

J'avais besoin de l'url complète pour la transmettre à une fonction js fetch. J'espère que cela vous aidera.

Je sais que c'est une vieille question. Mais je pense que les gens se heurtent encore beaucoup à cela.

Il existe quelques bibliothèques qui complètent la fonctionnalité Django par défaut. J'en ai essayé quelques-uns. J'aime la bibliothèque suivante lors du référencement inverse des URL absolues:

https://github.com/fusionbox/django-absoluteuri

Un autre que j'aime parce que vous pouvez facilement mettre en place un domaine, un protocole et un chemin est:

https://github.com/RRMoelker/django-full-url

Cette bibliothèque vous permet d'écrire simplement ce que vous voulez dans votre modèle, par exemple:

{{url_parts.domain}}

Si vous utilisez le framework django REST, vous pouvez utiliser la fonction inverse de rest_framework.reverse. Cela a le même comportement que django.core.urlresolvers.reverse, sauf qu'il utilise un paramètre de demande pour créer une URL complète.

from rest_framework.reverse import reverse

# returns the full url
url = reverse('view_name', args=(obj.pk,), request=request)

# returns only the relative url
url = reverse('view_name', args=(obj.pk,))

Modifié pour mentionner la disponibilité uniquement dans le cadre REST

J? ai compris:

wsgiref.util.request_uri(request.META)

Obtenez l'URI complet avec le schéma, l'hôte, le chemin du port et la requête.

Il existe également ABSOLUTE_URL_OVERRIDES comme paramètre

https://docs.djangoproject.com/en/2.1/ref/settings/#absolute-url-overrides

Mais cela remplace get_absolute_url (), ce qui n'est peut-être pas souhaitable.

Au lieu d'installer le framework de sites juste pour cela ou de faire certaines des autres choses mentionnées ici qui reposent sur un objet de demande, je pense que la meilleure solution est de le placer dans models.py

Définissez BASE_URL dans settings.py, puis importez-le dans models.py et créez une classe abstraite (ou ajoutez-la à celle que vous utilisez déjà) qui définit get_truly_absolute_url (). Cela pourrait être aussi simple que:

def get_truly_absolute_url(self):
    return BASE_URL + self.get_absolute_url()

Sous-classe et maintenant vous pouvez l'utiliser partout.

Comme mentionné dans d'autres réponses, request.build_absolute_uri()est parfait si vous y avez accès requestet le sitescadre est excellent tant que différentes URL pointent vers différentes bases de données.

Cependant, mon cas d'utilisation était légèrement différent. Mon serveur de transfert et le serveur de production accèdent à la même base de données, mais get_current_sitetous deux ont renvoyé le premier sitedans la base de données. Pour résoudre ce problème, vous devez utiliser une sorte de variable d'environnement. Vous pouvez soit utiliser 1) une variable d'environnement (quelque chose comme os.environ.get('SITE_URL', 'localhost:8000')) ou 2) différents SITE_IDs pour différents serveurs ET différents settings.py .

J'espère que quelqu'un trouvera cela utile!

Je suis tombé sur ce fil parce que je cherchais à créer un URI absolu pour une page de réussite. request.build_absolute_uri()m'a donné un URI pour ma vue actuelle, mais pour obtenir l'URI de ma vue de réussite, j'ai utilisé ce qui suit ....

request.build_absolute_uri (reverse ('success_view_name'))

request.get_host() vous donnera le domaine.

Vous pouvez aussi utiliser:

import socket
socket.gethostname()

Cela fonctionne bien pour moi,

Je ne sais pas trop comment cela fonctionne. Je crois que c'est un peu plus bas et retournera le nom d'hôte de votre serveur, qui pourrait être différent du nom d'hôte utilisé par votre utilisateur pour accéder à votre page.

Vous pouvez essayer "request.get_full_path ()"