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 __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 _allowed_methods(self): View

114
115
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
@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
    # 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

116
117
118
119
120
121
122
123
@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

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

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

154
155
156
157
158
159
160
161
162
163
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

129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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 = url_has_allowed_host_and_scheme(
            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

36
37
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.
141
142
143
144
145
146
147
148
149
150
151
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

100
101
102
103
104
105
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.
107
108
109
110
111
112
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'
    return response

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

Logout may be done via POST.
125
126
127
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.
125
126
127
128
129
130
131
132
133
134
135
136
137
138
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.
82
83
84
85
86
87
88
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