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', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
next_page = None LogoutView
redirect_field_name = 'next' LogoutView
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
success_url_allowed_hosts = set() SuccessURLAllowedHostsMixin
template_engine = None TemplateResponseMixin
template_name = 'registration/logged_out.html' LogoutView
template_name = None TemplateResponseMixin
Expand Collapse

Methods

def _allowed_methods(self): View

113
114
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.
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
@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("You tried to pass in the %s method name as a "
                            "keyword argument to %s(). Don't do that."
                            % (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)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
        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
    # take name and docstring from class
    update_wrapper(view, cls, updated=())
    # and possible attributes set by decorators
    # like csrf_exempt from dispatch
    update_wrapper(view, cls.dispatch, assigned=())
    return view

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

LogoutView

114
115
116
117
118
119
120
121
@method_decorator(never_cache)
def dispatch(self, request, *args, **kwargs):
    auth_logout(request)
    next_page = self.get_next_page()
    if next_page:
        # Redirect to this page until the session has been cleared.
        return HttpResponseRedirect(next_page)
    return super().dispatch(request, *args, **kwargs)

View

89
90
91
92
93
94
95
96
97
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

157
158
159
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

152
153
154
155
156
157
158
159
160
161
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'),
        **(self.extra_context or {})
    })
    return context

ContextMixin

23
24
25
26
27
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_next_page(self): LogoutView

127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
def get_next_page(self):
    if self.next_page is not None:
        next_page = resolve_url(self.next_page)
    elif settings.LOGOUT_REDIRECT_URL:
        next_page = resolve_url(settings.LOGOUT_REDIRECT_URL)
    else:
        next_page = self.next_page
    if (self.redirect_field_name in self.request.POST or
            self.redirect_field_name in self.request.GET):
        next_page = self.request.POST.get(
            self.redirect_field_name,
            self.request.GET.get(self.redirect_field_name)
        )
        url_is_safe = is_safe_url(
            url=next_page,
            allowed_hosts=self.get_success_url_allowed_hosts(),
            require_https=self.request.is_secure(),
        )
        # Security check -- Ensure the user-originating redirection URL is
        # safe.
        if not url_is_safe:
            next_page = self.request.path
    return next_page

def get_success_url_allowed_hosts(self): SuccessURLAllowedHostsMixin

34
35
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.
140
141
142
143
144
145
146
147
148
149
150
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

 99
100
101
102
103
104
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 __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
38
39
40
41
42
43
44
45
46
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 options(self, request, *args, **kwargs): View

Handle responding to requests for the OPTIONS HTTP verb.
106
107
108
109
110
111
def options(self, request, *args, **kwargs):
    """Handle responding to requests for the OPTIONS HTTP verb."""
    response = HttpResponse()
    response['Allow'] = ', '.join(self._allowed_methods())
    response['Content-Length'] = '0'
    return response

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

Logout may be done via POST.
123
124
125
def post(self, request, *args, **kwargs):
    """Logout may be done via POST."""
    return self.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.
124
125
126
127
128
129
130
131
132
133
134
135
136
137
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.
83
84
85
86
87
def setup(self, request, *args, **kwargs):
    """Initialize attributes shared by all view methods."""
    self.request = request
    self.args = args
    self.kwargs = kwargs