class LogoutView

from django.contrib.auth.views import LogoutView
Log out the user and display the 'You are logged out' message.

Attributes

  Defined in
content_type = None TemplateResponseMixin
extra_context = None ContextMixin
http_method_names = ['get', 'head', 'post', 'options'] LogoutView
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
next_page = None RedirectURLMixin
redirect_field_name = 'next' RedirectURLMixin
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
success_url_allowed_hosts = set() RedirectURLMixin
template_engine = None TemplateResponseMixin
template_name = 'registration/logged_out.html' LogoutView
template_name = None TemplateResponseMixin
view_is_async = False View
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
52
53
54
55
56
57
58
59
60
def __init__(self, **kwargs):
    """
    Constructor. Called in the URLconf; can contain helpful extra
    keyword arguments, and other things.
    """
    # Go through keyword arguments, and either save their values to our
    # instance, or raise an error.
    for key, value in kwargs.items():
        setattr(self, key, value)

def _allowed_methods(self): View

168
169
def _allowed_methods(self):
    return [m.upper() for m in self.http_method_names if hasattr(self, m)]

def as_view(cls, **initkwargs): View

Main entry point for a request-response process.
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
@classonlymethod
def as_view(cls, **initkwargs):
    """Main entry point for a request-response process."""
    for key in initkwargs:
        if key in cls.http_method_names:
            raise TypeError(
                "The method name %s is not accepted as a keyword argument "
                "to %s()." % (key, cls.__name__)
            )
        if not hasattr(cls, key):
            raise TypeError(
                "%s() received an invalid keyword %r. as_view "
                "only accepts arguments that are already "
                "attributes of the class." % (cls.__name__, key)
            )
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)
        self.setup(request, *args, **kwargs)
        if not hasattr(self, "request"):
            raise AttributeError(
                "%s instance has no 'request' attribute. Did you override "
                "setup() and forget to call super()?" % cls.__name__
            )
        return self.dispatch(request, *args, **kwargs)
    view.view_class = cls
    view.view_initkwargs = initkwargs
    # __name__ and __qualname__ are intentionally left unchanged as
    # view_class should be used to robustly determine the name of the view
    # instead.
    view.__doc__ = cls.__doc__
    view.__module__ = cls.__module__
    view.__annotations__ = cls.dispatch.__annotations__
    # Copy possible attributes set by decorators, e.g. @csrf_exempt, from
    # the dispatch method.
    view.__dict__.update(cls.dispatch.__dict__)
    # Mark the callback if the view class is async.
    if cls.view_is_async:
        view._is_coroutine = asyncio.coroutines._is_coroutine
    return view

def dispatch(self, request, *args, **kwargs):

LogoutView

139
140
141
142
143
144
145
146
147
@method_decorator(never_cache)
def dispatch(self, request, *args, **kwargs):
    if request.method.lower() == "get":
        warnings.warn(
            "Log out via GET requests is deprecated and will be removed in Django "
            "5.0. Use POST requests for logging out.",
            RemovedInDjango50Warning,
        )
    return super().dispatch(request, *args, **kwargs)

View

132
133
134
135
136
137
138
139
140
141
142
def dispatch(self, request, *args, **kwargs):
    # Try to dispatch to the right method; if a method doesn't exist,
    # defer to the error handler. Also defer to the error handler if the
    # request method isn't on the approved list.
    if request.method.lower() in self.http_method_names:
        handler = getattr(
            self, request.method.lower(), self.http_method_not_allowed
        )
    else:
        handler = self.http_method_not_allowed
    return handler(request, *args, **kwargs)

def get(self, request, *args, **kwargs):

LogoutView

Logout may be done via POST.
149
150
151
152
153
154
155
156
157
@method_decorator(csrf_protect)
def post(self, request, *args, **kwargs):
    """Logout may be done via POST."""
    auth_logout(request)
    redirect_to = self.get_success_url()
    if redirect_to != request.get_full_path():
        # Redirect to target page once the session has been cleared.
        return HttpResponseRedirect(redirect_to)
    return super().get(request, *args, **kwargs)

TemplateView

215
216
217
def get(self, request, *args, **kwargs):
    context = self.get_context_data(**kwargs)
    return self.render_to_response(context)

def get_context_data(self, **kwargs):

LogoutView

171
172
173
174
175
176
177
178
179
180
181
182
183
def get_context_data(self, **kwargs):
    context = super().get_context_data(**kwargs)
    current_site = get_current_site(self.request)
    context.update(
        {
            "site": current_site,
            "site_name": current_site.name,
            "title": _("Logged out"),
            "subtitle": None,
            **(self.extra_context or {}),
        }
    )
    return context

ContextMixin

28
29
30
31
32
def get_context_data(self, **kwargs):
    kwargs.setdefault("view", self)
    if self.extra_context is not None:
        kwargs.update(self.extra_context)
    return kwargs

def get_default_redirect_url(self):

LogoutView

Return the default redirect URL.
162
163
164
165
166
167
168
169
def get_default_redirect_url(self):
    """Return the default redirect URL."""
    if self.next_page:
        return resolve_url(self.next_page)
    elif settings.LOGOUT_REDIRECT_URL:
        return resolve_url(settings.LOGOUT_REDIRECT_URL)
    else:
        return self.request.path

RedirectURLMixin

Return the default redirect URL.
60
61
62
63
64
def get_default_redirect_url(self):
    """Return the default redirect URL."""
    if self.next_page:
        return resolve_url(self.next_page)
    raise ImproperlyConfigured("No URL to redirect to. Provide a next_page.")

def get_redirect_url(self): RedirectURLMixin

Return the user-originating redirect URL if it's safe.
45
46
47
48
49
50
51
52
53
54
55
def get_redirect_url(self):
    """Return the user-originating redirect URL if it's safe."""
    redirect_to = self.request.POST.get(
        self.redirect_field_name, self.request.GET.get(self.redirect_field_name)
    )
    url_is_safe = url_has_allowed_host_and_scheme(
        url=redirect_to,
        allowed_hosts=self.get_success_url_allowed_hosts(),
        require_https=self.request.is_secure(),
    )
    return redirect_to if url_is_safe else ""

def get_success_url(self): RedirectURLMixin

42
43
def get_success_url(self):
    return self.get_redirect_url() or self.get_default_redirect_url()

def get_success_url_allowed_hosts(self): RedirectURLMixin

57
58
def get_success_url_allowed_hosts(self):
    return {self.request.get_host(), *self.success_url_allowed_hosts}

def get_template_names(self): TemplateResponseMixin

Return a list of template names to be used for the request. Must return
a list. May not be called if render_to_response() is overridden.
196
197
198
199
200
201
202
203
204
205
206
207
def get_template_names(self):
    """
    Return a list of template names to be used for the request. Must return
    a list. May not be called if render_to_response() is overridden.
    """
    if self.template_name is None:
        raise ImproperlyConfigured(
            "TemplateResponseMixin requires either a definition of "
            "'template_name' or an implementation of 'get_template_names()'"
        )
    else:
        return [self.template_name]

def http_method_not_allowed(self, request, *args, **kwargs): View

144
145
146
147
148
149
150
151
def http_method_not_allowed(self, request, *args, **kwargs):
    logger.warning(
        "Method Not Allowed (%s): %s",
        request.method,
        request.path,
        extra={"status_code": 405, "request": request},
    )
    return HttpResponseNotAllowed(self._allowed_methods())

def options(self, request, *args, **kwargs): View

Handle responding to requests for the OPTIONS HTTP verb.
153
154
155
156
157
158
159
160
161
162
163
def options(self, request, *args, **kwargs):
    """Handle responding to requests for the OPTIONS HTTP verb."""
    response = HttpResponse()
    response.headers["Allow"] = ", ".join(self._allowed_methods())
    response.headers["Content-Length"] = "0"
    if self.view_is_async:
        async def func():
            return response
        return func()
    else:
        return response

def post(self, request, *args, **kwargs): LogoutView

Logout may be done via POST.
149
150
151
152
153
154
155
156
157
@method_decorator(csrf_protect)
def post(self, request, *args, **kwargs):
    """Logout may be done via POST."""
    auth_logout(request)
    redirect_to = self.get_success_url()
    if redirect_to != request.get_full_path():
        # Redirect to target page once the session has been cleared.
        return HttpResponseRedirect(redirect_to)
    return super().get(request, *args, **kwargs)

def render_to_response(self, context, **response_kwargs): TemplateResponseMixin

Return a response, using the `response_class` for this view, with a
template rendered with the given context.

Pass response_kwargs to the constructor of the response class.
180
181
182
183
184
185
186
187
188
189
190
191
192
193
def render_to_response(self, context, **response_kwargs):
    """
    Return a response, using the `response_class` for this view, with a
    template rendered with the given context.
    Pass response_kwargs to the constructor of the response class.
    """
    response_kwargs.setdefault("content_type", self.content_type)
    return self.response_class(
        request=self.request,
        template=self.get_template_names(),
        context=context,
        using=self.template_engine,
        **response_kwargs,
    )

def setup(self, request, *args, **kwargs): View

Initialize attributes shared by all view methods.
124
125
126
127
128
129
130
def setup(self, request, *args, **kwargs):
    """Initialize attributes shared by all view methods."""
    if hasattr(self, "get") and not hasattr(self, "head"):
        self.head = self.get
    self.request = request
    self.args = args
    self.kwargs = kwargs