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 = ['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.
53
54
55
56
57
58
59
60
61
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

178
179
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.
 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
118
@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:
        markcoroutinefunction(view)
    return view

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

LogoutView

133
134
135
136
@method_decorator(csrf_protect)
@method_decorator(never_cache)
def dispatch(self, request, *args, **kwargs):
    return super().dispatch(request, *args, **kwargs)

View

133
134
135
136
137
138
139
140
141
142
143
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): TemplateView

225
226
227
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

156
157
158
159
160
161
162
163
164
165
166
167
168
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

29
30
31
32
33
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.
147
148
149
150
151
152
153
154
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.
58
59
60
61
62
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.
43
44
45
46
47
48
49
50
51
52
53
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

40
41
def get_success_url(self):
    return self.get_redirect_url() or self.get_default_redirect_url()

def get_success_url_allowed_hosts(self): RedirectURLMixin

55
56
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.
206
207
208
209
210
211
212
213
214
215
216
217
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

145
146
147
148
149
150
151
152
153
154
155
156
157
158
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},
    )
    response = HttpResponseNotAllowed(self._allowed_methods())
    if self.view_is_async:
        async def func():
            return response
        return func()
    else:
        return response

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

Handle responding to requests for the OPTIONS HTTP verb.
163
164
165
166
167
168
169
170
171
172
173
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.
138
139
140
141
142
143
144
145
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.
190
191
192
193
194
195
196
197
198
199
200
201
202
203
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.
125
126
127
128
129
130
131
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