# Django Debug Toolbar

***

**1. Display Query Count**

```python
from django.conf import settings

# Custom middleware to count queries
class QueryCountMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        settings.QUERY_COUNT = 0
        response = self.get_response(request)
        settings.QUERY_COUNT += request.session['django_request_count']
        return response
```

**2. Time Each Request**

```python
from django.utils.deprecation import MiddlewareMixin

class TimeRequestMiddleware(MiddlewareMixin):
    def process_request(self, request):
        request.start_time = time.time()

    def process_response(self, request, response):
        response['X-Request-Time'] = '{:.3f}s'.format(time.time() - request.start_time)
        return response
```

**3. Display Template Tag Render Time**

```python
from django import template

register = template.Library()

@register.simple_tag
def render_time(template_name):
    start = time.time()
    template.loader.get_template(template_name).render()
    end = time.time()
    return end - start
```

**4. Track User Activity**

```python
from django.shortcuts import get_object_or_404

class UserActivityMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if request.user.is_authenticated:
            if request.method != 'GET':
                Activity.objects.create(user=request.user, action=request.method, object=request.path)
            else:
                activity = get_object_or_404(Activity, user=request.user, action='GET', object=request.path)
                activity.last_access = timezone.now()
                activity.save()
        response = self.get_response(request)
        return response
```

**5. Track Database Activity**

```python
from django.db import connections

class DatabaseActivityMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        request._queries = {}
        for alias in connections:
            request._queries[alias] = connections[alias].queries
        response = self.get_response(request)
        return response
```

**6. Display Current Time**

```python
from django.utils.html import format_html

class CurrentTimeMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        context = {'current_time': timezone.now().strftime('%Y-%m-%d %H:%M:%S')}
        response = self.get_response(request)
        response.context_data.update(context)
        return response
```

**7. Display Page Title**

```python
from django.shortcuts import get_object_or_404, render

def page_title(request, page_model, page_id):
    page = get_object_or_404(page_model, pk=page_id)
    context = {'page_title': page.title}
    return render(request, 'page_title.html', context)
```

**8. Display User IP Address**

```python
from django.utils.deprecation import MiddlewareMixin

class UserIPMiddleware(MiddlewareMixin):
    def process_request(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')
        request.META['REMOTE_IP'] = ip
```

**9. Display User Agent**

```python
from django.utils.deprecation import MiddlewareMixin

class UserAgentMiddleware(MiddlewareMixin):
    def process_request(self, request):
        request.META['HTTP_USER_AGENT'] = request.META.get('HTTP_USER_AGENT', '')
```

**10. Display Referrer**

```python
from django.utils.deprecation import MiddlewareMixin

class ReferrerMiddleware(MiddlewareMixin):
    def process_request(self, request):
        request.META['HTTP_REFERER'] = request.META.get('HTTP_REFERER', '')
```

**11. Display Response Content**

```python
from django.http import HttpResponse

def display_response_content(request):
    response = HttpResponse()
    response.content = request.body
    return response
```

**12. Display Response Headers**

```python
from django.http import HttpResponse

def display_response_headers(request):
    response = HttpResponse()
    response['X-Powered-By'] = 'Django'
    response['Content-Type'] = 'text/plain'
    return response
```

**13. Display Response Cookies**

```python
from django.http import HttpResponse

def display_response_cookies(request):
    response = HttpResponse()
    response.set_cookie('name', 'value')
    response.set_cookie('expires', 'expires_value', expires=timezone.now() + timedelta(days=1))
    return response
```

**14. Display Response Redirects**

```python
from django.http import HttpResponseRedirect

def display_response_redirects(request):
    response = HttpResponseRedirect('/')
    return response
```

**15. Display Session Data**

```python
from django.contrib.sessions.backends.db import SessionStore

def display_session_data(request):
    session = SessionStore(request.session.session_key)
    session.load()
    context = {'session_data': session.data}
    return render(request, 'session_data.html', context)
```

**16. Display Cache Headers**

```python
from django.http import HttpResponse

def display_cache_headers(request):
    response = HttpResponse()
    response['Cache-Control'] = 'max-age=600'
    return response
```

**17. Display Content Security Policy Headers**

```python
from django.http import HttpResponse

def display_csp_headers(request):
    response = HttpResponse()
    response['Content-Security-Policy'] = "default-src 'self'; script-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self'; style-src 'self' 'unsafe-inline'; font-src 'self'; object-src 'none'; plugin-types application/pdf; block-all-mixed-content;"
    return response
```

**18. Display X-Frame-Options Header**

```python
from django.http import HttpResponse

def display_x_frame_options_header(request):
    response = HttpResponse()
    response['X-Frame-Options'] = 'SAMEORIGIN'
    return response
```

**19. Display HSTS Header**

```python
from django.http import HttpResponse

def display_hsts_header(request):
    response = HttpResponse()
    response['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains; preload'
    return response
```

**20. Display Feature Policy Header**

```python
from django.http import HttpResponse

def display_feature_policy_header(request):
    response = HttpResponse()
    response['Feature-Policy'] = "camera 'none'; microphone 'none'; geolocation 'none'; payment 'none'"
    return response
```

**21. Display Permissions Policy Header**

```python
from django.http import HttpResponse

def display_permissions_policy_header(request):
    response = HttpResponse()
    response['Permissions-Policy'] = "geolocation=(self), microphone=(self), camera=(self), magnetometer=(self), ambient-light-sensor=(self), accelerometer=(self), gyroscope=(self)"
    return response
```

**22. Display Referrer Policy Header**

```python
from django.http import HttpResponse

def display_referrer_policy_header(request):
    response = HttpResponse()
    response['Referrer-Policy'] = 'no-referrer'
    return response
```

**23. Display Clear Site Data Header**

```python
from django.http import HttpResponse

def display_clear_site_data_header(request):
    response = HttpResponse()
    response['Clear-Site-Data'] = "'cookies', 'storage', 'executionContexts'"
    return response
```

**24. Display Expect-CT Header**

```python
from django.http import HttpResponse

def display_expect_ct_header(request):
    response = HttpResponse()
    response['Expect-CT'] = "max-age=31536000, enforce, report-uri='https://example.com/expect-ct-report'"
    return response
```

**25. Display Request ID Header**

```python
from django.contrib.sessions.backends.db import SessionStore

def display_request_id_header(request):
    session = SessionStore(request.session.session_key)
    session.load()
    request_id = session.get('request_id', None) or uuid.uuid4().hex
    session['request_id'] = request_id
    session.save()
    response = HttpResponse()
    response['X-Request-ID'] = request_id
    return response
```

**26. Display Response Headers**

```python
from django.shortcuts import render

def display_response_headers(request):
    context = {'headers': sorted(request.META.items())}
    return render(request, 'response_headers.html', context)
```

**27. Display Response Status Code**

```python
from django.http import HttpResponse

def display_response_status_code(request):
    response = HttpResponse()
    response.status_code = 200
    return response
```

**28. Display Templates Rendered**

```python
from django.contrib.staticfiles.storage import staticfiles_storage
from django.template import TemplateDoesNotExist

class RenderedTemplatesMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        request._rendered_templates = []
        response = self.get_response(request)
        return response

    def process_template_response(self, request, response):
        if response.template_name is not None:
            request._rendered_templates.append(response.template_name)
        return response
```

**29. Display View Function**

```python
from django.utils.deprecation import MiddlewareMixin

class ViewFunctionMiddleware(MiddlewareMixin):
    def process_view(self, request, view_func, view_args, view_kwargs):
        request.view_function = view_func
```

**30. Display View Arguments**

```python
from django.utils.deprecation import MiddlewareMixin

class ViewArgumentsMiddleware(MiddlewareMixin):
    def process_view(self, request, view_func, view_args, view_kwargs):
        request.view_args = view_args
```

**31. Display View Keywords**

```python
from django.utils.deprecation import MiddlewareMixin

class ViewKeywordsMiddleware(MiddlewareMixin):
    def process_view(self, request, view_func, view_args, view_kwargs):
        request.view_kwargs = view_kwargs
```

**32. Display Middleware Classes**

```python
from django.utils.deprecation import MiddlewareMixin

class MiddlewareClassesMiddleware(MiddlewareMixin):
    def __init__(self, get_response):
        super().__init__(get_response)
        self.middleware_classes = []

    def __call__(self, request):
        for middleware_class in settings.MIDDLEWARE:
            self.middleware_classes.append(middleware_class)
        response = self.get_response(request)
        return response
```

**33. Display Middleware Parameters**

```python
from django.utils.deprecation import MiddlewareMixin

class MiddlewareParametersMiddleware(MiddlewareMixin):
    def __init__(self, get_response):
        super().__init__(get_response)
        self.middleware_parameters = {}

    def __call__(self, request):
        for middleware_class in settings.MIDDLEWARE:
            middleware = middleware_class()
            self.middleware_parameters[middleware_class.__name__] = middleware.get_middleware_info()
        response = self.get_response(request)
        return response
```

**34. Display Installed Apps**

```python
from django.apps import apps
from django.contrib.auth.middleware import AuthenticationMiddleware

def display_installed_apps(request):
    context = {'installed_apps': apps.get_app_configs()}
    return render(request, 'installed_apps.html', context)
```

**35. Display Authentication Status**

```python
class AuthenticationStatusMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if hasattr(request, 'user'):
            request.user.is_authenticated = request.user.is_authenticated
        response = self.get_response(request)
        return response
```

**36. Display Permission Denied**

```python
from django.contrib.auth.views import permission_denied

class PermissionDeniedMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if not request.user.has_perms('myapp.can_view_page'):
            return permission_denied(request)
        response = self.get_response(request)
        return response
```