Dynamic Configuration Using Importlib

To implement dynamic configuration similar to Django's middleware system:

import importlib

module_path = 'lib_test.test'
module = importlib.import_module(module_path)
print(module)  # <module 'lib_test.test' ...>

Middleware-Style Configuration

Create a pluggable notification system:

# settings.py
NOTIFICATION_HANDLERS = [
    'notify.email.EmailService',
    'notify.sms.SmsService',
    'notify.wechat.WeChatService'
]

# __init__.py
def dispatch_notifications(message):
    for handler_path in settings.NOTIFICATION_HANDLERS:
        module_name, class_name = handler_path.rsplit('.', 1)
        handler_module = importlib.import_module(module_name)
        handler_class = getattr(handler_module, class_name)
        handler_instance = handler_class()
        handler_instance.send(message)

Cross-Site Request Forgery Protection

CSRF attacks occur when malicious sites impersonate legitimate ones. Django provides built-in portection:

CSRF Token Implementation

Django automatically adds a hidden token field to forms:

<form method="POST">
    {% csrf_token %}
    <!-- form fields -->
</form>

AJAX Integraiton

Method 1: Include token directly

$.ajax({
    url: '/endpoint/',
    method: 'POST',
    data: {
        'param': 'value',
        'csrfmiddlewaretoken': '{{ csrf_token }}'
    }
})

Method 2: Use Django's JavaScript helper

<script src="{% static 'csrf.js' %}"></script>

CSRF Decorators

Function-Based Views

from django.views.decorators.csrf import csrf_exempt, csrf_protect

@csrf_exempt
def unprotected_view(request):
    return HttpResponse("Unprotected")

@csrf_protect
def protected_view(request):
    return HttpResponse("Protected")

Class-Based Views

from django.utils.decorators import method_decorator

@method_decorator(csrf_exempt, name='dispatch')
class CustomView(View):
    def post(self, request):
        return HttpResponse("OK")

Django Settings Implementation

Django merges default and project-specific settings:

class LazySettings:
    def __init__(self):
        self._configured = False
        
    def _setup(self):
        # Load default settings
        from django.conf import global_settings
        for setting in dir(global_settings):
            if setting.isupper():
                setattr(self, setting, getattr(global_settings, setting))
        
        # Load project settings
        project_settings = os.environ.get('DJANGO_SETTINGS_MODULE')
        settings_module = importlib.import_module(project_settings)
        for setting in dir(settings_module):
            if setting.isupper():
                setattr(self, setting, getattr(settings_module, setting))
        
        self._configured = True

Authentication Module

User Management

from django.contrib.auth.models import User

# Create user
User.objects.create_user(username='user', password='pass')
User.objects.create_superuser(username='admin', password='pass', email='admin@example.com')

# Authenticate
from django.contrib.auth import authenticate
user = authenticate(request, username='user', password='pass')
if user:
    login(request, user)

Password Management

from django.contrib.auth.decorators import login_required

@login_required
def change_password(request):
    if request.method == 'POST':
        if request.user.check_password(request.POST['old_password']):
            request.user.set_password(request.POST['new_password'])
            request.user.save()
    return render(request, 'password_form.html')

Extending User Model

from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    phone_number = models.CharField(max_length=15)
    registration_date = models.DateTimeField(auto_now_add=True)

Pluggable Configuration Design

Implement a configuration system inspired by Django:

# conf/__init__.py
class Configuration:
    def __init__(self):
        # Load defaults
        from . import defaults
        for key in dir(defaults):
            if key.isupper():
                setattr(self, key, getattr(defaults, key))
        
        # Load custom settings
        custom_settings = os.environ.get('APP_SETTINGS_MODULE')
        if custom_settings:
            settings_module = importlib.import_module(custom_settings)
            for key in dir(settings_module):
                if key.isupper():
                    setattr(self, key, getattr(settings_module, key))

settings = Configuration()