Beherskelse af Django Signals: Dybdegående Gennemgang af Post-save og Pre-delete Hooks til Robuste Applikationer

            # myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User

# Definer en modtagerfunktion
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        # Logik til at oprette en profil for den nye bruger
        print(f"Ny bruger '{instance.username}' oprettet. En profil kan nu genereres.")

# Alternativt, forbind manuelt (mindre almindeligt med decorator for indbyggede signaler)
# from django.apps import AppConfig
# class MyAppConfig(AppConfig):
#     name = 'myapp'
#     def ready(self):
#         from . import signals  # Importer din signalfil

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models
from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)
    birth_date = models.DateField(null=True, blank=True)

    def __str__(self):
        return self.user.username + "'s Profile"

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User
from .models import UserProfile

@receiver(post_save, sender=User)
def create_or_update_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)
        print(f"UserProfile for {instance.username} oprettet.")
    # Valgfrit: Hvis du også vil håndtere opdateringer til User og kaskadere til profilen
    # instance.userprofile.save() # Dette ville udløse post_save for UserProfile, hvis du havde en

            

              
                Copy
              
            
          

            # myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product
from django.core.cache import cache

@receiver(post_save, sender=Product)
def update_product_cache_and_search_index(sender, instance, **kwargs):
    # Invalider specifik produkt-cache
    cache.delete(f"product_detail_{instance.pk}")
    print(f"Cache invalideret for produkt-ID: {instance.pk}")

    # Simuler opdatering af et søgeindeks
    # I et virkeligt scenarie ville dette måske involvere et kald til et eksternt søgetjeneste-API
    print(f"Produkt {instance.name} (ID: {instance.pk}) markeret til opdatering af søgeindeks.")
    # search_service.index_document(instance)

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class AuditLog(models.Model):
    model_name = models.CharField(max_length=255)
    object_id = models.IntegerField()
    action = models.CharField(max_length=50) # 'created', 'updated'
    timestamp = models.DateTimeField(auto_now_add=True)
    changes = models.JSONField(blank=True, null=True)

    def __str__(self):
        return f"[{self.timestamp}] {self.model_name}({self.object_id}) {self.action}"

class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import AuditLog, BlogPost # Eksempelmodel til revision

@receiver(post_save, sender=BlogPost)
def log_blogpost_changes(sender, instance, created, **kwargs):
    action = 'created' if created else 'updated'
    # For opdateringer vil du måske fange specifikke feltændringer. Kræver sammenligning før lagring.
    # For enkelthedens skyld logger vi her kun handlingen.
    AuditLog.objects.create(
        model_name=sender.__name__,
        object_id=instance.pk,
        action=action,
        # changes=previous_state_vs_current_state # Mere kompleks logik kræves for dette
    )
    print(f"Revisionslog oprettet for BlogPost ID: {instance.pk}, handling: {action}")

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class Order(models.Model):
    customer_email = models.EmailField()
    status = models.CharField(max_length=50, default='pending')
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return f"Order #{self.pk} - {self.customer_email}"

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Order
from django.core.mail import send_mail
# from myapp.tasks import send_order_confirmation_email_task # For asynkrone opgaver

@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created and instance.status == 'pending': # Eller 'completed' hvis behandlet synkront
        subject = f"Bekræftelse på din ordre #{instance.pk}"
        message = f"Kære kunde, tak for din ordre! Dit samlede ordrebeløb er {instance.total_amount}."
        from_email = "noreply@example.com"
        recipient_list = [instance.customer_email]

        try:
            send_mail(subject, message, from_email, recipient_list, fail_silently=False)
            print(f"Ordrebekræftelses-e-mail sendt til {instance.customer_email} for Ordre ID: {instance.pk}")
        except Exception as e:
            print(f"Fejl ved afsendelse af e-mail for Ordre ID {instance.pk}: {e}")

        # For bedre ydeevne og pålidelighed, især med eksterne tjenester,
        # overvej at uddelegere dette til en asynkron opgavekø (f.eks. Celery).
        # send_order_confirmation_email_task.delay(instance.pk)

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class Document(models.Model):
    title = models.CharField(max_length=255)
    file = models.FileField(upload_to='documents/')

    def __str__(self):
        return self.title

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Document

@receiver(pre_delete, sender=Document)
def delete_document_file_on_delete(sender, instance, **kwargs):
    # Sørg for, at filen eksisterer, før du forsøger at slette den
    if instance.file:
        instance.file.delete(save=False) # slet den faktiske fil fra lageret
        print(f"Filen '{instance.file.name}' for Dokument ID: {instance.pk} slettet fra lageret.")

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class Customer(models.Model):
    name = models.CharField(max_length=255)
    email = models.EmailField(unique=True)
    is_active = models.BooleanField(default=True)
    archived_at = models.DateTimeField(null=True, blank=True)

    def __str__(self):
        return self.name

class ArchivedCustomer(models.Model):
    original_customer_id = models.IntegerField(unique=True)
    name = models.CharField(max_length=255)
    email = models.EmailField()
    archived_date = models.DateTimeField(auto_now_add=True)
    original_data_snapshot = models.JSONField(blank=True, null=True)

    def __str__(self):
        return f"Arkiveret: {self.name} (ID: {self.original_customer_id})"

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Customer, ArchivedCustomer
from django.core.exceptions import PermissionDenied # For at forhindre faktisk sletning
from django.utils import timezone

@receiver(pre_delete, sender=Customer)
def archive_customer_instead_of_delete(sender, instance, **kwargs):
    # Opret en arkiveret kopi
    ArchivedCustomer.objects.create(
        original_customer_id=instance.pk,
        name=instance.name,
        email=instance.email,
        original_data_snapshot={
            'is_active': instance.is_active,
            'archived_at': instance.archived_at.isoformat() if instance.archived_at else None
        }
    )
    print(f"Kunde ID: {instance.pk} arkiveret i stedet for slettet.")
    # Forhindr den faktiske sletning i at fortsætte ved at rejse en undtagelse
    raise PermissionDenied(f"Kunde '{instance.name}' kan ikke slettes permanent, kun arkiveres.")
    # Bemærk: For et ægte soft-delete-mønster ville man typisk overskrive delete()-metoden
    # på modellen eller bruge en brugerdefineret manager, da signaler ikke let kan "annullere" en ORM-operation.
```

# myapp/models.py
from django.db import models

class Project(models.Model):
    title = models.CharField(max_length=255)
    description = models.TextField(blank=True)

    def __str__(self):
        return self.title

class Task(models.Model):
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    name = models.CharField(max_length=255)
    is_completed = models.BooleanField(default=False)

    def __str__(self):
        return self.name

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Project, Task
from django.core.exceptions import PermissionDenied

@receiver(pre_delete, sender=Project)
def prevent_deletion_if_active_tasks(sender, instance, **kwargs):
    if instance.task_set.filter(is_completed=False).exists():
        raise PermissionDenied(
            f"Kan ikke slette Projekt '{instance.title}', fordi det stadig har aktive opgaver."
        )
    print(f"Projekt '{instance.title}' har ingen aktive opgaver; sletning fortsætter.")

            

              
                Copy