Django Signaalide Meisterdamine: Põhjalik Sukeldumine Post-save ja Pre-delete Hookidesse Tugevate Rakenduste Jaoks

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

# Defineeri vastuvõtja funktsioon
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        # Loogika uue kasutaja profiili loomiseks
        print(f"Uus kasutaja '{instance.username}' loodud. Nüüd saab luua profiili.")

# Alternatiivselt, ühenda käsitsi (dekoraatoriga sisseehitatud signaalide puhul vähem levinud)
# from django.apps import AppConfig
# class MyAppConfig(AppConfig):
#     name = 'myapp'
#     def ready(self):
#         from . import signals  # Impordi oma signaalide fail

            

              
                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"Kasutajaprofiil kasutajale {instance.username} loodud.")
    # Valikuline: kui soovite käsitleda ka kasutaja uuendusi ja kaskaadida need profiilile
    # instance.userprofile.save() # See käivitaks UserProfile'i post_save, kui teil see oleks

            

              
                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):
    # Tühista konkreetse toote vahemälu
    cache.delete(f"product_detail_{instance.pk}")
    print(f"Vahemälu tühistatud toote ID jaoks: {instance.pk}")

    # Simuleeri otsinguindeksi uuendamist
    # Reaalses stsenaariumis võib see hõlmata välise otsinguteenuse API kutsumist
    print(f"Toode {instance.name} (ID: {instance.pk}) märgitud otsinguindeksi uuendamiseks.")
    # 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 # Näidismudel auditeerimiseks

@receiver(post_save, sender=BlogPost)
def log_blogpost_changes(sender, instance, created, **kwargs):
    action = 'created' if created else 'updated'
    # Uuenduste puhul võiksite salvestada konkreetsed välja muudatused. Nõuab pre-save võrdlust.
    # Lihtsuse huvides logime siin lihtsalt tegevuse.
    AuditLog.objects.create(
        model_name=sender.__name__,
        object_id=instance.pk,
        action=action,
        # changes=previous_state_vs_current_state # Selleks on vaja keerukamat loogikat
    )
    print(f"Auditilogi loodud Blogipostituse ID jaoks: {instance.pk}, tegevus: {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 # Asünkroonsete ülesannete jaoks

@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created and instance.status == 'pending': # Või 'completed', kui töödeldakse sünkroonselt
        subject = f"Teie tellimuse #{instance.pk} kinnitus"
        message = f"Lugupeetud klient, täname teid tellimuse eest! Teie tellimuse kogusumma on {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"Tellimuse kinnituskiri saadetud aadressile {instance.customer_email} tellimuse ID: {instance.pk}")
        except Exception as e:
            print(f"Viga e-kirja saatmisel tellimuse ID {instance.pk} jaoks: {e}")

        # Parema jõudluse ja usaldusväärsuse tagamiseks, eriti väliste teenustega,
        # kaaluge selle edasilükkamist asünkroonsesse ülesannete järjekorda (nt 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):
    # Veenduge, et fail eksisteerib enne selle kustutamist
    if instance.file:
        instance.file.delete(save=False) # kustuta tegelik fail salvestuskohast
        print(f"Fail '{instance.file.name}' dokumendi ID jaoks: {instance.pk} kustutatud salvestuskohast.")

            

              
                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"Arhiveeritud: {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 # Tegeliku kustutamise vältimiseks
from django.utils import timezone

@receiver(pre_delete, sender=Customer)
def archive_customer_instead_of_delete(sender, instance, **kwargs):
    # Loo arhiveeritud koopia
    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"Kliendi ID: {instance.pk} arhiveeritud kustutamise asemel.")
    # Takista tegeliku kustutamise jätkumist erindi viskamisega
    raise PermissionDenied(f"Klienti '{instance.name}' ei saa püsivalt kustutada, ainult arhiveerida.")
    # Märkus: Tõelise pehme kustutamise mustri jaoks kirjutaksite tavaliselt üle delete() meetodi
    # mudelil või kasutaksite kohandatud haldurit, kuna signaalid ei saa ORM-i operatsiooni lihtsalt "tühistada".
```

# 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"Projekti '{instance.title}' ei saa kustutada, sest sellel on endiselt aktiivseid ülesandeid."
        )
    print(f"Projektil '{instance.title}' pole aktiivseid ülesandeid; kustutamine jätkub.")

            

              
                Copy