Bài 2.4: Advanced Model Fields - Phần 4 - Computed Fields & Model Mixins

**Series Navigation:** - [Bài 2.1: JSONField](/django-advance/advanced-model-fields-phan-1) - [Bài 2.2: ArrayField & HStoreField](/django-advance/advanced-model-fields-phan-2) - [Bài 2.3: Custom Model Fields](/django-advance/advanced-model-fields-phan-3) - **Bài 2.4 (bài này): Computed Fields & Model Mixins** 👈

Mục Tiêu Bài 2.4

Sau khi hoàn thành Bài 2.4 này, bạn sẽ:

✅ Implement computed fields với @property decorator
✅ Optimize expensive operations với @cached_property
✅ Tạo reusable Model Mixins
✅ Hiểu Abstract Models vs Concrete inheritance
✅ Build Custom Managers và QuerySets
✅ Sử dụng Django Signals hiệu quả
✅ Combine các patterns để build scalable models

Computed Fields với @property

What Are Computed Fields?

Computed fields (hay derived fields) là attributes không được lưu trong database mà được tính toán on-the-fly từ các fields khác.

Use Cases:

Full name từ first_name + last_name
Age từ date_of_birth
Total price từ quantity × unit_price
Status based on conditions
Formatted display values

Basic @property Pattern

Syntax:

class MyModel(models.Model):    field1 = models.CharField(max_length=100)    field2 = models.IntegerField()        @property    def computed_field(self):        return some_calculation(self.field1, self.field2)

Example - User Full Name:

class User(models.Model):    first_name = models.CharField(max_length=50)    last_name = models.CharField(max_length=50)        @property    def full_name(self):        return f"{self.first_name} {self.last_name}".strip()

Usage:

user = User.objects.get(id=1)print(user.full_name)  # "John Doe" # In templates{{ user.full_name }} # Cannot query by computed fieldsUser.objects.filter(full_name="John Doe")  # ❌ Error!

Key Points:

✅ No database storage needed
✅ Always up-to-date
✅ Clean, readable code
❌ Cannot query or filter
❌ Cannot use in order_by()
❌ Recalculated every access

Property Setter Pattern

Use Case: Allow assignment with validation/transformation.

Pattern:

@propertydef field(self):    return self._field @field.setterdef field(self, value):    # Validate or transform    self._field = process(value)

Example - Temperature Conversion:

class WeatherRecord(models.Model):    _temperature_celsius = models.DecimalField(        max_digits=5,         decimal_places=2,        db_column='temperature_celsius'    )        @property    def temperature_celsius(self):        return self._temperature_celsius        @temperature_celsius.setter    def temperature_celsius(self, value):        self._temperature_celsius = value        @property    def temperature_fahrenheit(self):        return (self._temperature_celsius * 9/5) + 32        @temperature_fahrenheit.setter    def temperature_fahrenheit(self, value):        self._temperature_celsius = (value - 32) * 5/9

Usage:

record = WeatherRecord.objects.create(temperature_celsius=25)print(record.temperature_fahrenheit)  # 77.0 # Set via Fahrenheitrecord.temperature_fahrenheit = 68print(record.temperature_celsius)  # 20.0

Advanced Computed Field Examples

Example 1 - Order Total Calculation:

class Order(models.Model):    created_at = models.DateTimeField(auto_now_add=True)    discount_percent = models.DecimalField(        max_digits=5,         decimal_places=2,         default=0    )    tax_rate = models.DecimalField(        max_digits=5,         decimal_places=2,         default=0.1  # 10%    )        @property    def subtotal(self):        """Sum of all order items"""        return sum(item.total for item in self.items.all())        @property    def discount_amount(self):        return self.subtotal * (self.discount_percent / 100)        @property    def subtotal_after_discount(self):        return self.subtotal - self.discount_amount        @property    def tax_amount(self):        return self.subtotal_after_discount * self.tax_rate        @property    def total(self):        return self.subtotal_after_discount + self.tax_amount        @property    def total_items(self):        return self.items.count() class OrderItem(models.Model):    order = models.ForeignKey(Order, related_name='items')    product = models.ForeignKey('Product')    quantity = models.PositiveIntegerField()    unit_price = models.DecimalField(max_digits=10, decimal_places=2)        @property    def total(self):        return self.quantity * self.unit_price

Example 2 - Status Based on Conditions:

from django.utils import timezonefrom datetime import timedelta class Subscription(models.Model):    user = models.ForeignKey(User)    plan = models.CharField(max_length=50)    start_date = models.DateField()    end_date = models.DateField()    is_cancelled = models.BooleanField(default=False)        @property    def is_active(self):        """Active if within date range and not cancelled"""        today = timezone.now().date()        return (            not self.is_cancelled and            self.start_date <= today <= self.end_date        )        @property    def days_remaining(self):        if not self.is_active:            return 0        today = timezone.now().date()        delta = self.end_date - today        return max(0, delta.days)        @property    def status(self):        if self.is_cancelled:            return 'cancelled'                today = timezone.now().date()                if today < self.start_date:            return 'pending'        elif today > self.end_date:            return 'expired'        elif self.days_remaining <= 7:            return 'expiring_soon'        else:            return 'active'        @property    def status_display(self):        status_map = {            'pending': 'Pending Activation',            'active': 'Active',            'expiring_soon': 'Expiring Soon',            'expired': 'Expired',            'cancelled': 'Cancelled'        }        return status_map.get(self.status, 'Unknown')

Example 3 - Age Calculation:

from datetime import date class Person(models.Model):    first_name = models.CharField(max_length=50)    last_name = models.CharField(max_length=50)    date_of_birth = models.DateField()        @property    def age(self):        today = date.today()        born = self.date_of_birth        return today.year - born.year - (            (today.month, today.day) < (born.month, born.day)        )        @property    def is_adult(self):        return self.age >= 18        @property    def age_group(self):        age = self.age        if age < 13:            return 'child'        elif age < 20:            return 'teenager'        elif age < 60:            return 'adult'        else:            return 'senior'

Cached Properties - Performance Optimization

The Problem with @property

Issue: Properties are recalculated every time they're accessed.

Example:

order = Order.objects.get(id=1)print(order.subtotal)  # Query: SELECT * FROM order_items WHERE order_id=1print(order.subtotal)  # Query again!print(order.total)     # Query AGAIN for subtotal calculation

Result: Multiple queries for same data = performance problem.

@cached_property to the Rescue

Import:

from django.utils.functional import cached_property

Usage:

class Order(models.Model):    # ... fields ...        @cached_property    def subtotal(self):        """Cached - only calculated once per instance"""        return sum(item.total for item in self.items.all())

How It Works:

First access: Calculate và cache result
Subsequent accesses: Return cached value
Cache lifetime: Duration of instance in memory

Example:

order = Order.objects.get(id=1)print(order.subtotal)  # Query: SELECT * FROM order_items...print(order.subtotal)  # No query! Uses cached valueprint(order.subtotal)  # Still no query!

When to Use @cached_property

Use When:

✅ Expensive database queries
✅ Complex calculations
✅ External API calls
✅ File system operations
✅ Frequently accessed properties

Don't Use When:

❌ Simple calculations (no performance gain)
❌ Values that change during instance lifetime
❌ Properties that must always be fresh

Cache Invalidation Strategies

Problem: Cached value becomes stale after updates.

Solution 1 - Manual Invalidation:

class Order(models.Model):    @cached_property    def subtotal(self):        return sum(item.total for item in self.items.all())        def add_item(self, product, quantity, unit_price):        item = self.items.create(            product=product,            quantity=quantity,            unit_price=unit_price        )        # Invalidate cache        try:            del self.subtotal        except AttributeError:            pass        return item

Solution 2 - Reload from Database:

order = Order.objects.get(id=1)print(order.subtotal)  # 100.00 # Add item via admin or another processOrderItem.objects.create(order=order, ...) # Refresh to clear cacheorder.refresh_from_db()print(order.subtotal)  # 150.00 (recalculated)

Solution 3 - Signal-Based Invalidation:

from django.db.models.signals import post_save, post_deletefrom django.dispatch import receiver @receiver([post_save, post_delete], sender=OrderItem)def invalidate_order_cache(sender, instance, **kwargs):    """Clear order cached properties when items change"""    try:        del instance.order.subtotal        del instance.order.total    except AttributeError:        pass

Real-World Example - User Statistics

class User(models.Model):    username = models.CharField(max_length=150, unique=True)    date_joined = models.DateTimeField(auto_now_add=True)        @cached_property    def post_count(self):        """Total posts by user"""        return self.posts.count()        @cached_property    def comment_count(self):        """Total comments by user"""        return self.comments.count()        @cached_property    def total_likes_received(self):        """Total likes on user's posts"""        return sum(post.likes.count() for post in self.posts.all())        @cached_property    def reputation_score(self):        """Calculate user reputation"""        # Expensive calculation        score = 0        score += self.post_count * 10        score += self.comment_count * 2        score += self.total_likes_received * 5        return score        @cached_property    def is_verified(self):        """Check if user has verified email and phone"""        return (            self.email_verified and             self.phone_verified and            self.post_count >= 5        )

Usage in View:

def user_profile(request, username):    user = User.objects.get(username=username)        # All these access cached values after first calculation    context = {        'user': user,        'post_count': user.post_count,  # Calculated once        'reputation': user.reputation_score,  # Uses cached post_count        'is_verified': user.is_verified,    }    return render(request, 'profile.html', context)

Model Mixins - Reusable Components

What Are Mixins?

Mixin = A class that provides specific functionality to be inherited by models.

Key Characteristics:

Not used standalone
Combined with other classes (multiple inheritance)
Provide focused, reusable functionality
Follow Single Responsibility Principle

Common Mixin Patterns

Pattern 1: TimestampMixin

Purpose: Add created_at và updated_at to models.

Implementation:

from django.db import models class TimestampMixin(models.Model):    """Add automatic timestamp tracking"""    created_at = models.DateTimeField(auto_now_add=True)    updated_at = models.DateTimeField(auto_now=True)        class Meta:        abstract = True  # ⚠️ CRITICAL: Makes it a mixin

Usage:

class Article(TimestampMixin):    title = models.CharField(max_length=200)    content = models.TextField()        # Automatically has created_at and updated_at class Comment(TimestampMixin):    article = models.ForeignKey(Article)    text = models.TextField()        # Also has created_at and updated_at

Why Abstract?

Without abstract = True: Creates separate database table
With abstract = True: Fields merged into child model's table

Pattern 2: SoftDeleteMixin

Purpose: Mark records as deleted instead of removing them.

Implementation:

from django.db import modelsfrom django.utils import timezone class SoftDeleteMixin(models.Model):    """Soft delete functionality"""    is_deleted = models.BooleanField(default=False)    deleted_at = models.DateTimeField(null=True, blank=True)        class Meta:        abstract = True        def delete(self, using=None, keep_parents=False):        """Override delete to soft delete"""        self.is_deleted = True        self.deleted_at = timezone.now()        self.save()        def hard_delete(self):        """Actually delete from database"""        super().delete()        def restore(self):        """Restore soft-deleted record"""        self.is_deleted = False        self.deleted_at = None        self.save()

Usage:

class Product(SoftDeleteMixin):    name = models.CharField(max_length=200)    price = models.DecimalField(max_digits=10, decimal_places=2) # Soft deleteproduct = Product.objects.get(id=1)product.delete()  # is_deleted=True, still in database # Query includes deletedProduct.objects.all()  # Returns deleted products too # Filter out deletedProduct.objects.filter(is_deleted=False) # Restoreproduct.restore() # Permanently deleteproduct.hard_delete()

Better Version with Custom Manager:

class SoftDeleteManager(models.Manager):    """Manager that filters out soft-deleted by default"""        def get_queryset(self):        return super().get_queryset().filter(is_deleted=False)        def with_deleted(self):        """Include soft-deleted records"""        return super().get_queryset()        def deleted_only(self):        """Only soft-deleted records"""        return super().get_queryset().filter(is_deleted=True) class SoftDeleteMixin(models.Model):    is_deleted = models.BooleanField(default=False)    deleted_at = models.DateTimeField(null=True, blank=True)        objects = SoftDeleteManager()  # Default manager    all_objects = models.Manager()  # Access all records        class Meta:        abstract = True        def delete(self, using=None, keep_parents=False):        self.is_deleted = True        self.deleted_at = timezone.now()        self.save()        def hard_delete(self):        super().delete()        def restore(self):        self.is_deleted = False        self.deleted_at = None        self.save()

Improved Usage:

# Default: excludes deletedProduct.objects.all()  # Only active products # Include deletedProduct.objects.with_deleted() # Only deletedProduct.objects.deleted_only() # Access everythingProduct.all_objects.all()

Pattern 3: AuditMixin

Purpose: Track who created/modified records and when.

Implementation:

from django.conf import settings class AuditMixin(models.Model):    """Track creation and modification"""    created_at = models.DateTimeField(auto_now_add=True)    created_by = models.ForeignKey(        settings.AUTH_USER_MODEL,        on_delete=models.SET_NULL,        null=True,        related_name='%(class)s_created'    )    updated_at = models.DateTimeField(auto_now=True)    updated_by = models.ForeignKey(        settings.AUTH_USER_MODEL,        on_delete=models.SET_NULL,        null=True,        related_name='%(class)s_updated'    )        class Meta:        abstract = True        def save(self, *args, **kwargs):        # Note: User must be passed explicitly or via middleware        user = kwargs.pop('user', None)        if user:            if not self.pk:  # New record                self.created_by = user            self.updated_by = user        super().save(*args, **kwargs)

Related Name Pattern:

%(class)s_created: Replaced with lowercase model name
Example: Article → article_created, Comment → comment_created
Prevents related name conflicts

Usage:

class Document(AuditMixin):    title = models.CharField(max_length=200)    content = models.TextField() # In view with request.userdocument = Document(title='Test', content='...')document.save(user=request.user) # Query documents created by useruser_documents = Document.objects.filter(created_by=request.user) # Query who last updatedprint(f"Last updated by {document.updated_by.username}")

Advanced: Middleware Integration:

# middleware.pyfrom threading import local _user = local() class CurrentUserMiddleware:    def __init__(self, get_response):        self.get_response = get_response        def __call__(self, request):        _user.value = getattr(request, 'user', None)        response = self.get_response(request)        return response def get_current_user():    return getattr(_user, 'value', None) # models.pyclass AuditMixin(models.Model):    # ... fields ...        def save(self, *args, **kwargs):        user = kwargs.pop('user', None) or get_current_user()        if user and user.is_authenticated:            if not self.pk:                self.created_by = user            self.updated_by = user        super().save(*args, **kwargs)

Pattern 4: UUIDMixin

Purpose: Use UUIDs instead of auto-incrementing IDs.

Implementation:

import uuidfrom django.db import models class UUIDMixin(models.Model):    """Use UUID as primary key"""    id = models.UUIDField(        primary_key=True,        default=uuid.uuid4,        editable=False    )        class Meta:        abstract = True

Benefits:

Globally unique (safe for distributed systems)
Non-sequential (security)
Can generate before saving

Usage:

class User(UUIDMixin):    username = models.CharField(max_length=150) # ID generated automaticallyuser = User.objects.create(username='john')print(user.id)  # UUID('550e8400-e29b-41d4-a716-446655440000')

Combining Multiple Mixins

Order Matters!

class Article(UUIDMixin, TimestampMixin, SoftDeleteMixin, AuditMixin):    """    Inherits from multiple mixins:    - UUID primary key    - created_at, updated_at    - Soft delete functionality    - created_by, updated_by tracking    """    title = models.CharField(max_length=200)    content = models.TextField()        class Meta:        ordering = ['-created_at']

MRO (Method Resolution Order):

Python searches left-to-right for methods
Place most specific first
Models.Model should be last (implicit)

Custom Managers and QuerySets

What Are Managers?

Manager = Interface for database operations on a model.

Default Manager:

Article.objects.all()  # 'objects' is the default manager

Custom QuerySet Pattern

Purpose: Add reusable query methods.

Implementation:

from django.db import models class ArticleQuerySet(models.QuerySet):    """Custom queryset with article-specific filters"""        def published(self):        """Only published articles"""        return self.filter(status='published')        def draft(self):        """Only draft articles"""        return self.filter(status='draft')        def by_author(self, author):        """Articles by specific author"""        return self.filter(author=author)        def featured(self):        """Featured articles"""        return self.filter(is_featured=True)        def recent(self, days=7):        """Articles from last N days"""        from django.utils import timezone        from datetime import timedelta        cutoff = timezone.now() - timedelta(days=days)        return self.filter(created_at__gte=cutoff) class ArticleManager(models.Manager):    """Custom manager"""    def get_queryset(self):        return ArticleQuerySet(self.model, using=self._db)        # Proxy methods for convenience    def published(self):        return self.get_queryset().published()        def draft(self):        return self.get_queryset().draft()        def by_author(self, author):        return self.get_queryset().by_author(author)        def featured(self):        return self.get_queryset().featured()        def recent(self, days=7):        return self.get_queryset().recent(days) class Article(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    status = models.CharField(        max_length=20,        choices=[('draft', 'Draft'), ('published', 'Published')]    )    is_featured = models.BooleanField(default=False)    author = models.ForeignKey('auth.User')    created_at = models.DateTimeField(auto_now_add=True)        objects = ArticleManager()  # Custom manager

Usage - Chainable Methods:

# Single filterArticle.objects.published() # Chained filtersArticle.objects.published().featured() # Multiple chainsArticle.objects.published().by_author(user).recent(days=30) # Still works with standard QuerySet methodsArticle.objects.published().order_by('-created_at')[:10]

Modern Pattern: QuerySet as Manager

Simpler approach using QuerySet.as_manager():

class ArticleQuerySet(models.QuerySet):    def published(self):        return self.filter(status='published')        def draft(self):        return self.filter(status='draft')        def featured(self):        return self.filter(is_featured=True) class Article(models.Model):    # ... fields ...        objects = ArticleQuerySet.as_manager()  # 🎯 Simple!

No separate Manager class needed!

Multiple Managers Pattern

Use Case: Different default querysets.

class ArticleQuerySet(models.QuerySet):    def published(self):        return self.filter(status='published')        def draft(self):        return self.filter(status='draft') class PublishedManager(models.Manager):    def get_queryset(self):        return ArticleQuerySet(self.model, using=self._db).published() class Article(models.Model):    # ... fields ...        objects = ArticleQuerySet.as_manager()  # All articles    published = PublishedManager()  # Only published (default filter)

Usage:

# All articlesArticle.objects.all() # Only published (automatic filter)Article.published.all() # Published and featuredArticle.published.filter(is_featured=True)

Django Signals

What Are Signals?

Signals = Notification system that allows decoupled apps to get notified when certain actions occur.

Common Signals:

pre_save: Before model.save()
post_save: After model.save()
pre_delete: Before model.delete()
post_delete: After model.delete()
m2m_changed: When ManyToMany relation changes

Signal Pattern

Basic Structure:

from django.db.models.signals import post_savefrom django.dispatch import receiver @receiver(post_save, sender=MyModel)def my_handler(sender, instance, created, **kwargs):    """    Args:        sender: Model class        instance: Actual instance being saved        created: True if new record, False if update        **kwargs: Additional arguments    """    if created:        # Handle new record        pass    else:        # Handle update        pass

Real-World Signal Examples

Example 1 - User Profile Creation:

from django.contrib.auth.models import Userfrom django.db.models.signals import post_savefrom django.dispatch import receiver class UserProfile(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    bio = models.TextField(blank=True)    avatar = models.ImageField(upload_to='avatars/', null=True)    phone = models.CharField(max_length=20, blank=True) @receiver(post_save, sender=User)def create_user_profile(sender, instance, created, **kwargs):    """Automatically create profile when user is created"""    if created:        UserProfile.objects.create(user=instance) @receiver(post_save, sender=User)def save_user_profile(sender, instance, **kwargs):    """Save profile when user is saved"""    instance.userprofile.save()

Example 2 - Send Notification on Comment:

from django.db.models.signals import post_savefrom django.dispatch import receiver @receiver(post_save, sender=Comment)def notify_author(sender, instance, created, **kwargs):    """Notify article author when someone comments"""    if created:        article = instance.article        author = article.author                # Send notification (email, push, etc.)        Notification.objects.create(            user=author,            message=f"New comment on '{article.title}'",            link=article.get_absolute_url()        )

Example 3 - Invalidate Cache on Update:

from django.core.cache import cachefrom django.db.models.signals import post_save, post_deletefrom django.dispatch import receiver @receiver([post_save, post_delete], sender=Article)def invalidate_article_cache(sender, instance, **kwargs):    """Clear cache when article changes"""    cache_keys = [        f'article_{instance.id}',        'article_list',        f'author_articles_{instance.author.id}'    ]    cache.delete_many(cache_keys)

Signal Best Practices

1. Keep Handlers Light:

# ❌ Bad: Heavy operation in signal@receiver(post_save, sender=Order)def process_order(sender, instance, created, **kwargs):    if created:        # Don't do this! Blocks request        generate_invoice_pdf(instance)        send_confirmation_email(instance)        update_inventory(instance) # ✅ Good: Offload to Celery@receiver(post_save, sender=Order)def process_order(sender, instance, created, **kwargs):    if created:        # Queue background tasks        process_order_task.delay(instance.id)

2. Avoid Circular Signals:

# ❌ Bad: Infinite loop@receiver(post_save, sender=Article)def update_slug(sender, instance, **kwargs):    instance.slug = slugify(instance.title)    instance.save()  # 🔥 Triggers post_save again! # ✅ Good: Use pre_save or conditional save@receiver(pre_save, sender=Article)def update_slug(sender, instance, **kwargs):    if not instance.slug:        instance.slug = slugify(instance.title)

3. Use update_fields to Prevent Signals:

# Disable signals by using update()Article.objects.filter(id=article_id).update(view_count=F('view_count') + 1)# No post_save signal triggered # Or be explicit with save()article.view_count += 1article.save(update_fields=['view_count'])

4. Disconnect Signals When Needed:

from django.db.models.signals import post_save # Temporarily disable signalpost_save.disconnect(my_handler, sender=MyModel)# Do operationsinstance.save()  # Signal not triggered# Re-enablepost_save.connect(my_handler, sender=MyModel)

Combining All Patterns

Complete Example: Blog System

from django.db import modelsfrom django.contrib.auth.models import Userfrom django.utils.text import slugifyfrom django.utils.functional import cached_property # Mixinsclass TimestampMixin(models.Model):    created_at = models.DateTimeField(auto_now_add=True)    updated_at = models.DateTimeField(auto_now=True)    class Meta:        abstract = True class SoftDeleteMixin(models.Model):    is_deleted = models.BooleanField(default=False)    deleted_at = models.DateTimeField(null=True, blank=True)        objects = SoftDeleteManager()    all_objects = models.Manager()        class Meta:        abstract = True        def delete(self, *args, **kwargs):        self.is_deleted = True        self.deleted_at = timezone.now()        self.save() # Custom QuerySetclass ArticleQuerySet(models.QuerySet):    def published(self):        return self.filter(status='published', is_deleted=False)        def by_author(self, author):        return self.filter(author=author)        def with_view_count(self):        """Annotate with view count"""        return self.annotate(view_count=models.Count('views')) # Modelclass Article(TimestampMixin, SoftDeleteMixin):    STATUS_CHOICES = [        ('draft', 'Draft'),        ('published', 'Published'),    ]        title = models.CharField(max_length=200)    slug = models.SlugField(unique=True, blank=True)    content = models.TextField()    author = models.ForeignKey(User, related_name='articles')    status = models.CharField(max_length=20, choices=STATUS_CHOICES)    is_featured = models.BooleanField(default=False)        objects = ArticleQuerySet.as_manager()        class Meta:        ordering = ['-created_at']        def save(self, *args, **kwargs):        # Auto-generate slug        if not self.slug:            self.slug = slugify(self.title)        super().save(*args, **kwargs)        # Computed fields    @property    def is_published(self):        return self.status == 'published'        @cached_property    def comment_count(self):        return self.comments.filter(is_deleted=False).count()        @cached_property    def like_count(self):        return self.likes.count()        # Helper methods    def publish(self):        self.status = 'published'        self.save(update_fields=['status', 'updated_at'])        def unpublish(self):        self.status = 'draft'        self.save(update_fields=['status', 'updated_at']) # Signals@receiver(post_save, sender=Article)def article_published_notification(sender, instance, created, **kwargs):    """Notify followers when article is published"""    if instance.status == 'published' and not created:        # Check if status just changed        if 'status' in kwargs.get('update_fields', []):            notify_followers.delay(instance.id)

Usage:

# Create draftarticle = Article.objects.create(    title='My Article',    content='...',    author=request.user,    status='draft') # Publish (triggers signal)article.publish() # Query published articlespublished_articles = Article.objects.published().by_author(request.user) # Access computed fieldsprint(f"Comments: {article.comment_count}")  # Cachedprint(f"Likes: {article.like_count}")  # Cached

Tóm Tắt Bài 2.4

Trong Bài 2.4 này, bạn đã học:

✅ Computed Fields:

@property decorator cho derived fields
Property setters cho assignment validation
Real-world examples: full_name, age, order totals, status

✅ Cached Properties:

@cached_property cho performance optimization
When to use và when not to use
Cache invalidation strategies

✅ Model Mixins:

TimestampMixin (created_at, updated_at)
SoftDeleteMixin (is_deleted, custom manager)
AuditMixin (created_by, updated_by tracking)
UUIDMixin (UUID primary keys)
Combining multiple mixins

✅ Custom Managers & QuerySets:

Custom QuerySet với reusable filters
QuerySet.as_manager() pattern
Multiple managers pattern
Chainable query methods

✅ Django Signals:

post_save, pre_save, post_delete, pre_delete
Signal handlers và best practices
Avoid circular signals
Offload heavy work to background tasks

✅ Integration:

Combining all patterns effectively
Real-world blog system example

Exercises

Exercise 1: Product with Inventory Tracking

Requirements:

Create Product model với TimestampMixin và SoftDeleteMixin
Add computed fields:
- is_available: True if stock > 0 và not deleted
- is_low_stock: True if stock < low_stock_threshold
- stock_status: Returns 'out_of_stock', 'low_stock', or 'in_stock'
Add cached property:
- average_rating: Calculate from related Review model
Custom QuerySet methods:
- available(): Products in stock
- low_stock(): Products below threshold
- by_category(category): Filter by category
Signal: Notify admin when stock becomes low

Hints:

Use @property for simple computed fields
Use @cached_property for average_rating (expensive query)
Use QuerySet.as_manager() pattern
Use post_save signal with condition check

Exercise 2: Event Management System

Requirements:

Create Event model với AuditMixin và UUIDMixin
Add computed fields:
- is_upcoming: Event date in future
- is_past: Event date has passed
- is_today: Event is today
- days_until_event: Days remaining (0 if past)
- registration_status: 'not_started', 'open', 'closed', 'full'
Add cached properties:
- attendee_count: Count registered attendees
- available_seats: max_attendees - attendee_count
Custom Manager:
- upcoming(): Future events only
- past(): Past events only
- open_for_registration(): Events accepting registrations
Signal: Send reminder email 1 day before event

Hints:

Use django.utils.timezone for date comparisons
Property for registration_status depends on multiple conditions
Use F() expression for available_seats calculation
Consider Celery Beat for reminder emails

Requirements:

Create Post model combining:
- TimestampMixin
- SoftDeleteMixin
- AuditMixin
Add computed fields:
- is_edited: True if updated_at > created_at + 5 minutes
- engagement_rate: (likes + comments) / views * 100
Add cached properties:
- like_count
- comment_count
- share_count
- total_engagement: Sum of above
Custom QuerySet:
- trending(): High engagement in last 24 hours
- by_hashtag(tag): Posts containing hashtag
- with_engagement(): Annotate with counts
Signals:
- Invalidate cached properties when like/comment added
- Notify followers when post is created

Hints:

Use timedelta for is_edited calculation
Store view_count in database field
Use django-taggit for hashtags (optional)
Use post_save signal on Like and Comment models
Clear cached_property with del instance.property_name

Next Steps

Congratulations! 🎉 You've completed Bài 2: Advanced Model Fields (all 4 parts).

In Bài 3: Advanced QuerySets và Database Optimization, you'll learn:

QuerySet evaluation và lazy loading
select_related() vs prefetch_related()
Solving N+1 query problem
Aggregation và Annotation
F() và Q() objects advanced usage
Database indexing strategies
Query performance profiling với Django Debug Toolbar

Navigation:

← Bài 2.3: Custom Model Fields
Bài 2.4: Computed Fields & Model Mixins (current)
Bài 3: Advanced QuerySets →

#cached-property

Advanced Model Fields - Phần 4 - Computed Fields & Model Mixins