Postępując zgodnie z samouczkiem znajdującym się tutaj , nie mogę utworzyć niestandardowej strony błędu 500 lub 404. Jeśli wpiszę zły adres URL, strona wyświetli domyślną stronę błędu. Czy jest coś, co powinienem sprawdzić, co uniemożliwiłoby wyświetlenie strony niestandardowej?

Katalogi plików:

mysite/
    mysite/
        __init__.py
        __init__.pyc
        settings.py
        settings.pyc
        urls.py
        urls.pyc
        wsgi.py
        wsgi.pyc
    polls/
        templates/
            admin/
                base_site.html
            404.html
            500.html
            polls/
                detail.html
                index.html
        __init__.py
        __init__.pyc
        admin.py
        admin.pyc
        models.py
        models.pyc
        tests.py
        urls.py
        urls.pyc
        view.py
        views.pyc
    templates/
    manage.py

w mysite / settings.py mam te włączone:

DEBUG = False
TEMPLATE_DEBUG = DEBUG

#....

TEMPLATE_DIRS = (
    'C:/Users/Me/Django/mysite/templates', 
)

w ramach mysite / polls / urls.py:

from django.conf.urls import patterns, url

from polls import views

urlpatterns = patterns('',
    url(r'^$', views.index, name='index'),
    url(r'^(?P<poll_id>\d+)/$', views.detail, name='detail'),
    url(r'^(?P<poll_id>\d+)/results/$', views.results, name='results'),
    url(r'^(?P<poll_id>\d+)/vote/$', views.vote, name='vote'),
)

Mogę opublikować inny potrzebny kod, ale co powinienem zmienić, aby uzyskać niestandardową stronę błędu 500, jeśli używam złego adresu URL?

Edytować

ROZWIĄZANIE: Miałem dodatkowy

TEMPLATE_DIRS

w moim settings.py i to było przyczyną problemu

Pod swoim głównym views.pydodaj własną, niestandardową implementację następujących dwóch widoków i po prostu skonfiguruj szablony 404.html i 500.html z tym, co chcesz wyświetlić.

Dzięki temu rozwiązaniu nie trzeba dodawać żadnego niestandardowego kodu urls.py

Oto kod:

from django.shortcuts import render_to_response
from django.template import RequestContext


def handler404(request, *args, **argv):
    response = render_to_response('404.html', {},
                                  context_instance=RequestContext(request))
    response.status_code = 404
    return response


def handler500(request, *args, **argv):
    response = render_to_response('500.html', {},
                                  context_instance=RequestContext(request))
    response.status_code = 500
    return response

Aktualizacja

handler404i handler500są eksportowane zmienne konfiguracyjne ciągów Django znalezione w django/conf/urls/__init__.py. Dlatego powyższa konfiguracja działa.

Aby powyższa konfiguracja działała, należy zdefiniować następujące zmienne w swoim urls.pypliku i skierować wyeksportowane zmienne Django do ścieżki w języku Python, w której zdefiniowane są te widoki funkcjonalne Django, na przykład:

# project/urls.py

handler404 = 'my_app.views.handler404'
handler500 = 'my_app.views.handler500'

Aktualizacja dla Django 2.0

Podpisy dla widoków obsługi zostały zmienione w Django 2.0: https://docs.djangoproject.com/en/2.0/ref/views/#error-views

Jeśli używasz widoków jak powyżej, program handler404 zakończy się niepowodzeniem z komunikatem:

„funkcja handler404 () otrzymała nieoczekiwany argument słowa kluczowego„ wyjątek ””

W takim przypadku zmodyfikuj swoje widoki w ten sposób:

def handler404(request, exception, template_name="404.html"):
    response = render_to_response(template_name)
    response.status_code = 404
    return response

Oficjalna odpowiedź:

Oto link do oficjalnej dokumentacji na temat konfigurowania niestandardowych widoków błędów:

https://docs.djangoproject.com/en/stable/topics/http/views/#customizing-error-views

Mówi, aby dodać takie linie w swoim URLconf (ustawienie ich gdziekolwiek indziej nie przyniesie efektu):

handler404 = 'mysite.views.my_custom_page_not_found_view'
handler500 = 'mysite.views.my_custom_error_view'
handler403 = 'mysite.views.my_custom_permission_denied_view'
handler400 = 'mysite.views.my_custom_bad_request_view'

Możesz również dostosować widok błędów CSRF, modyfikując ustawienie CSRF_FAILURE_VIEW.

Domyślne programy obsługi błędów:

Warto czytać dokumentację z obsługą domyślne błędów page_not_found, server_error, permission_deniedi bad_request. Domyślnie oni korzystać z tych szablonów, czy mogą je znaleźć odpowiednio: 404.html, 500.html, 403.html, i 400.html.

Więc jeśli wszystko, co chcesz zrobić, to stworzyć ładne strony błędów, po prostu utwórz te pliki w TEMPLATE_DIRSkatalogu, nie musisz w ogóle edytować URLConf. Przeczytaj dokumentację, aby zobaczyć, które zmienne kontekstu są dostępne.

W Django 1.10 i nowszych domyślny widok błędów CSRF używa szablonu 403_csrf.html.

Mam cię:

Nie zapominaj, że DEBUGmusi być ustawione na False, aby te działały, w przeciwnym razie zostaną użyte normalne procedury obsługi debugowania.

Dodaj te linie do urls.py

urls.py

from django.conf.urls import (
handler400, handler403, handler404, handler500
)

handler400 = 'my_app.views.bad_request'
handler403 = 'my_app.views.permission_denied'
handler404 = 'my_app.views.page_not_found'
handler500 = 'my_app.views.server_error'

# ...

i zaimplementuj nasze niestandardowe widoki w views.py.

views.py

from django.shortcuts import (
render_to_response
)
from django.template import RequestContext

# HTTP Error 400
def bad_request(request):
    response = render_to_response(
        '400.html',
        context_instance=RequestContext(request)
        )

        response.status_code = 400

        return response

# ...

Ze strony, do której się odwołałeś:

Kiedy podniesiesz Http404 z poziomu widoku, Django załaduje specjalny widok poświęcony obsłudze błędów 404. Znajduje ją, szukając zmiennej handler404 w twoim głównym URLconf (i tylko w twoim głównym URLconf; ustawienie handler404 gdziekolwiek indziej nie odniesie skutku), która jest łańcuchem w składni kropkowanej Pythona - tym samym formacie, którego używają normalne wywołania zwrotne URLconf. Sam widok 404 nie ma nic specjalnego: to tylko normalny widok.

Więc uważam, że musisz dodać coś takiego do swojego urls.py:

handler404 = 'views.my_404_view'

i podobne dla handler500.

Jeśli wszystko, czego potrzebujesz, to pokazać niestandardowe strony, które mają kilka wymyślnych komunikatów o błędach dla Twojej witryny, kiedy DEBUG = False, dodaj dwa szablony o nazwach 404.html i 500.html do katalogu szablonów, a te niestandardowe strony będą automatycznie pobierane po 404 lub 500 jest podniesiony.

W Django 2. * możesz użyć tej konstrukcji w views.py

def handler404(request, exception):
    return render(request, 'errors/404.html', locals())

W settings.py

DEBUG = False

if DEBUG is False:
    ALLOWED_HOSTS = [
        '127.0.0.1:8000',
        '*',
    ]

if DEBUG is True:
    ALLOWED_HOSTS = []

W urls.py

# https://docs.djangoproject.com/en/2.0/topics/http/views/#customizing-error-views
handler404 = 'YOUR_APP_NAME.views.handler404'

Zwykle tworzę default_app i obsługuję błędy całej witryny, w tym procesory kontekstu.

settings.py:

DEBUG = False
TEMPLATE_DEBUG = DEBUG
ALLOWED_HOSTS = ['localhost']  #provide your host name

i po prostu dodaj swoje strony 404.htmli 500.htmldo folderu szablonów. usuń 404.htmli 500.htmlz szablonów w aplikacji ankiet.

Zrób błąd, na stronie błędu dowiedz się, skąd django ładuje szablony, mam na myśli stos ścieżek. W podstawowym katalogu template_dir dodaj te strony html 500.html , 404.html . W przypadku wystąpienia tych błędów odpowiednie pliki szablonów zostaną automatycznie załadowane.

Możesz także dodać strony dla innych kodów błędów, takich jak 400 i 403 .

Mam nadzieję, że to pomoże !!!

W Django 3.xzaakceptowana odpowiedź nie zadziała, ponieważ render_to_responsezostała całkowicie usunięta, a także wprowadzono więcej zmian od wersji, dla której działała zaakceptowana odpowiedź.

Są tam również inne odpowiedzi, ale przedstawiam nieco bardziej przejrzystą odpowiedź:

W głównym urls.pypliku:

handler404 = 'yourapp.views.handler404'
handler500 = 'yourapp.views.handler500'

W yourapp/views.pypliku:

def handler404(request, exception):
    context = {}
    response = render(request, "pages/errors/404.html", context=context)
    response.status_code = 404
    return response


def handler500(request):
    context = {}
    response = render(request, "pages/errors/500.html", context=context)
    response.status_code = 500
    return response

Upewnij się, że zaimportowałeś render()do yourapp/views.pypliku:

from django.shortcuts import render

Uwaga dodatkowa: render_to_response()został 2.xuznany za przestarzały w Django i został całkowicie usunięty w wersji 3.x.

Jako jeden wiersz (dla strony ogólnej 404):

from django.shortcuts import render_to_response
from django.template import RequestContext

return render_to_response('error/404.html', {'exception': ex},
                                      context_instance=RequestContext(request), status=404)

Nie jest wymagany żaden dodatkowy widok. https://docs.djangoproject.com/en/3.0/ref/views/

Po prostu umieść pliki błędów w katalogu głównym szablonów

• 404.html
• 400.html
• 403.html
• 500.html

Powinien również używać strony błędu, gdy debugowanie jest fałszywe

# views.py
def handler404(request, exception):
    context = RequestContext(request)
    err_code = 404
    response = render_to_response('404.html', {"code":err_code}, context)
    response.status_code = 404
    return response

# <project_folder>.urls.py
handler404 = 'todo.views.handler404' 

Działa to na django 2.0

Pamiętaj, aby umieścić swój niestandardowy 404.htmlplik w folderze szablonów aplikacji.

Django 3.0

tutaj jest link jak dostosować widoki błędów

tutaj jest link jak renderować widok

w urls.py(głównym folderze projektu) umieść:

handler404 = 'my_app_name.views.custom_page_not_found_view'
handler500 = 'my_app_name.views.custom_error_view'
handler403 = 'my_app_name.views.custom_permission_denied_view'
handler400 = 'my_app_name.views.custom_bad_request_view'

aw tej aplikacji ( my_app_name) umieść views.py:

def custom_page_not_found_view(request, exception):
    return render(request, "errors/404.html", {})

def custom_error_view(request, exception=None):
    return render(request, "errors/500.html", {})

def custom_permission_denied_view(request, exception=None):
    return render(request, "errors/403.html", {})

def custom_bad_request_view(request, exception=None):
    return render(request, "errors/400.html", {})

UWAGA: error/404.htmlto ścieżka, jeśli umieścisz pliki w folderze szablonów projektów (nie aplikacji)templates/errors/404.html więc umieść pliki tam, gdzie chcesz, i napisz właściwą ścieżkę.

UWAGA 2: Jeśli po przeładowaniu strony nadal widzisz stary szablon, zmień go settings.py DEBUG=True, zapisz, a następnie ponownie do False(aby zrestartować serwer i zebrać nowe pliki).

Spróbuj przenieść szablony błędów do .../Django/mysite/templates/?

Jestem pewien co do tego, ale myślę, że muszą one być „globalne” dla witryny.