Menguasai Sinyal Django: Ulasan Mendalam tentang Hook Post-save dan Pre-delete untuk Aplikasi yang Tangguh

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

# Definisikan fungsi penerima
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        # Logika untuk membuat profil bagi pengguna baru
        print(f"Pengguna baru '{instance.username}' dibuat. Profil sekarang dapat dibuat.")

# Atau, hubungkan secara manual (kurang umum dengan dekorator untuk sinyal bawaan)
# from django.apps import AppConfig
# class MyAppConfig(AppConfig):
#     name = 'myapp'
#     def ready(self):
#         from . import signals  # Impor file sinyal Anda

            

              
                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 untuk {instance.username} dibuat.")
    # Opsional: Jika Anda juga ingin menangani pembaruan pada User dan menyebarkannya ke profil
    # instance.userprofile.save() # Ini akan memicu post_save untuk UserProfile jika Anda memilikinya

            

              
                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):
    # Membatalkan cache produk tertentu
    cache.delete(f"product_detail_{instance.pk}")
    print(f"Cache dibatalkan untuk produk ID: {instance.pk}")

    # Mensimulasikan pembaruan indeks pencarian
    # Dalam skenario dunia nyata, ini mungkin melibatkan pemanggilan API layanan pencarian eksternal
    print(f"Produk {instance.name} (ID: {instance.pk}) ditandai untuk pembaruan indeks pencarian.")
    # 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 # Contoh model untuk diaudit

@receiver(post_save, sender=BlogPost)
def log_blogpost_changes(sender, instance, created, **kwargs):
    action = 'created' if created else 'updated'
    # Untuk pembaruan, Anda mungkin ingin menangkap perubahan field tertentu. Membutuhkan perbandingan pre-save.
    # Untuk kesederhanaan di sini, kita hanya akan mencatat aksinya.
    AuditLog.objects.create(
        model_name=sender.__name__,
        object_id=instance.pk,
        action=action,
        # changes=previous_state_vs_current_state # Logika lebih kompleks diperlukan untuk ini
    )
    print(f"Log audit dibuat untuk BlogPost ID: {instance.pk}, aksi: {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 # Untuk tugas asinkron

@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created and instance.status == 'pending': # Atau 'completed' jika diproses secara sinkron
        subject = f"Konfirmasi Pesanan Anda #{instance.pk}"
        message = f"Pelanggan yang terhormat, terima kasih atas pesanan Anda! Total pesanan Anda adalah {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"Email konfirmasi pesanan dikirim ke {instance.customer_email} untuk Order ID: {instance.pk}")
        except Exception as e:
            print(f"Error mengirim email untuk Order ID {instance.pk}: {e}")

        # Untuk kinerja dan keandalan yang lebih baik, terutama dengan layanan eksternal,
        # pertimbangkan untuk menundanya ke antrian tugas asinkron (mis., 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):
    # Pastikan file ada sebelum mencoba menghapusnya
    if instance.file:
        instance.file.delete(save=False) # hapus file aktual dari penyimpanan
        print(f"File '{instance.file.name}' untuk Document ID: {instance.pk} dihapus dari penyimpanan.")

            

              
                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"Diarsipkan: {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 # Untuk mencegah penghapusan sebenarnya
from django.utils import timezone

@receiver(pre_delete, sender=Customer)
def archive_customer_instead_of_delete(sender, instance, **kwargs):
    # Buat salinan yang diarsipkan
    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"Customer ID: {instance.pk} diarsipkan alih-alih dihapus.")
    # Mencegah penghapusan sebenarnya berlanjut dengan memunculkan pengecualian
    raise PermissionDenied(f"Customer '{instance.name}' tidak dapat dihapus keras, hanya diarsipkan.")
    # Catatan: Untuk pola soft-delete yang sebenarnya, biasanya Anda akan menimpa metode delete()
    # pada model atau menggunakan manajer kustom, karena sinyal tidak dapat "membatalkan" operasi ORM dengan mudah.
```

# 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"Tidak dapat menghapus Proyek '{instance.title}' karena masih memiliki tugas aktif."
        )
    print(f"Proyek '{instance.title}' tidak memiliki tugas aktif; penghapusan berlanjut.")

            

              
                Copy