1 bài viết được gắn thẻ "Django"

# blog/views.py
from django.http import JsonResponse, Http404
from django.shortcuts import render, get_object_or_404, redirect
from django.contrib import messages

from .models import BaiViet


def danh_sach_bai_viet(request):
    ds = BaiViet.objects.filter(da_xuat_ban=True).select_related("tac_gia")
    return render(request, "blog/danh_sach.html", {"bai_viet": ds})


def chi_tiet_bai_viet(request, slug: str):
    bai_viet = get_object_or_404(BaiViet, slug=slug, da_xuat_ban=True)
    return render(request, "blog/chi_tiet.html", {"bai_viet": bai_viet})

# blog/urls.py
from django.urls import path
from . import views

app_name = "blog"

urlpatterns = [
    path("", views.danh_sach_bai_viet, name="danh_sach"),
    path("<slug:slug>/", views.chi_tiet_bai_viet, name="chi_tiet"),
]

# config/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("blog/", include("blog.urls")),
]

# blog/models.py
from django.db import models
from django.contrib.auth.models import User
from django.urls import reverse
from django.utils import timezone
from django.utils.text import slugify


class DanhMuc(models.Model):
    ten = models.CharField("Tên danh mục", max_length=100, unique=True)
    slug = models.SlugField("Đường dẫn", max_length=120, unique=True)

    class Meta:
        verbose_name = "Danh mục"
        verbose_name_plural = "Danh mục"
        ordering = ["ten"]

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.ten, allow_unicode=True)
        super().save(*args, **kwargs)

    def __str__(self):
        return self.ten


class BaiViet(models.Model):
    TRANG_THAI = [
        ("nhap", "Bản nháp"),
        ("cho_duyet", "Chờ duyệt"),
        ("xuat_ban", "Đã xuất bản"),
    ]

    tieu_de = models.CharField("Tiêu đề", max_length=250)
    slug = models.SlugField("Đường dẫn", max_length=260, unique=True, db_index=True)
    noi_dung = models.TextField("Nội dung")
    tom_tat = models.CharField("Tóm tắt", max_length=500, blank=True)

    tac_gia = models.ForeignKey(
        User, on_delete=models.CASCADE, related_name="bai_viet",
        verbose_name="Tác giả",
    )
    danh_muc = models.ForeignKey(
        DanhMuc, on_delete=models.SET_NULL, null=True, blank=True,
        related_name="bai_viet", verbose_name="Danh mục",
    )
    the = models.ManyToManyField("The", blank=True, related_name="bai_viet", verbose_name="Thẻ")

    trang_thai = models.CharField(max_length=20, choices=TRANG_THAI, default="nhap", db_index=True)
    luot_xem = models.PositiveIntegerField("Lượt xem", default=0)
    ngay_tao = models.DateTimeField(auto_now_add=True, db_index=True)
    ngay_cap_nhat = models.DateTimeField(auto_now=True)
    ngay_xuat_ban = models.DateTimeField(null=True, blank=True)

    class Meta:
        verbose_name = "Bài viết"
        verbose_name_plural = "Bài viết"
        ordering = ["-ngay_tao"]
        indexes = [
            models.Index(fields=["trang_thai", "-ngay_tao"]),
            models.Index(fields=["tac_gia", "trang_thai"]),
        ]
        constraints = [
            models.CheckConstraint(
                check=models.Q(luot_xem__gte=0),
                name="luot_xem_khong_am",
            ),
        ]

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.tieu_de, allow_unicode=True)[:260]
        if self.trang_thai == "xuat_ban" and self.ngay_xuat_ban is None:
            self.ngay_xuat_ban = timezone.now()
        super().save(*args, **kwargs)

    def get_absolute_url(self):
        return reverse("blog:chi_tiet", kwargs={"slug": self.slug})

    @property
    def da_xuat_ban(self):
        return self.trang_thai == "xuat_ban"

    def __str__(self):
        return self.tieu_de


class The(models.Model):
    ten = models.CharField(max_length=60, unique=True)
    slug = models.SlugField(max_length=80, unique=True)

    def __str__(self):
        return self.ten

from django.db.models import Q, F, Count, Sum, Avg, Max, Case, When, Value, IntegerField

# --- Lọc ---
BaiViet.objects.filter(trang_thai="xuat_ban")
BaiViet.objects.filter(luot_xem__gte=1000)
BaiViet.objects.filter(tieu_de__icontains="python")
BaiViet.objects.filter(danh_muc__isnull=True)
BaiViet.objects.filter(ngay_tao__year=2026, ngay_tao__month=10)
BaiViet.objects.filter(Q(trang_thai="xuat_ban") | Q(luot_xem__gt=5000))
BaiViet.objects.exclude(trang_thai="nhap")

# --- Sắp xếp & giới hạn ---
BaiViet.objects.order_by("-luot_xem")[:10]
BaiViet.objects.order_by(F("luot_xem").desc(nulls_last=True))

# --- Truy vấn liên bảng ---
BaiViet.objects.filter(the__ten="python").distinct()
BaiViet.objects.filter(danh_muc__slug="huong-dan")

# --- Aggregate ---
BaiViet.objects.aggregate(tong_luot_xem=Sum("luot_xem"), tb=Avg("luot_xem"))

# --- Annotate (tính toán trên từng bản ghi) ---
DanhMuc.objects.annotate(so_bai=Count("bai_viet")).filter(so_bai__gt=0)

# --- Cập nhật bằng F() — tránh race condition ---
BaiViet.objects.filter(pk=1).update(luot_xem=F("luot_xem") + 1)

# --- bulk_create / bulk_update — nhanh hơn nhiều lần ---
BaiViet.objects.bulk_create([BaiViet(tieu_de=f"Bài {i}") for i in range(1000)], batch_size=500)

# ❌ SAI — đọc rồi ghi, có race condition
bv = BaiViet.objects.get(pk=1)
bv.luot_xem = bv.luot_xem + 1     # hai request đồng thời → mất 1 lượt
bv.save()

# ✅ ĐÚNG — database tự tăng, atomic
BaiViet.objects.filter(pk=1).update(luot_xem=F("luot_xem") + 1)

# blog/admin.py
from django.contrib import admin
from django.utils.html import format_html
from .models import BaiViet, DanhMuc, The


@admin.register(DanhMuc)
class DanhMucAdmin(admin.ModelAdmin):
    list_display = ("ten", "slug", "so_bai_viet")
    search_fields = ("ten",)
    prepopulated_fields = {"slug": ("ten",)}

    @admin.display(description="Số bài viết")
    def so_bai_viet(self, obj):
        return obj.bai_viet.count()


@admin.register(BaiViet)
class BaiVietAdmin(admin.ModelAdmin):
    list_display = ("tieu_de", "tac_gia", "danh_muc", "trang_thai_badge", "luot_xem", "ngay_tao")
    list_filter = ("trang_thai", "danh_muc", "ngay_tao")
    search_fields = ("tieu_de", "noi_dung", "tac_gia__username")
    prepopulated_fields = {"slug": ("tieu_de",)}
    date_hierarchy = "ngay_tao"
    autocomplete_fields = ("tac_gia", "danh_muc")
    filter_horizontal = ("the",)
    list_select_related = ("tac_gia", "danh_muc")       # ← tránh N+1 trong admin
    readonly_fields = ("luot_xem", "ngay_tao", "ngay_cap_nhat")
    list_per_page = 25
    actions = ["duyet_hang_loat"]

    fieldsets = (
        ("Nội dung", {"fields": ("tieu_de", "slug", "tom_tat", "noi_dung")}),
        ("Phân loại", {"fields": ("danh_muc", "the")}),
        ("Xuất bản", {"fields": ("tac_gia", "trang_thai", "ngay_xuat_ban")}),
        ("Thống kê", {"fields": ("luot_xem", "ngay_tao", "ngay_cap_nhat"), "classes": ("collapse",)}),
    )

    @admin.display(description="Trạng thái", ordering="trang_thai")
    def trang_thai_badge(self, obj):
        mau = {"nhap": "#6b7280", "cho_duyet": "#f59e0b", "xuat_ban": "#16a34a"}[obj.trang_thai]
        return format_html(
            '<span style="background:{};color:#fff;padding:2px 8px;border-radius:10px">{}</span>',
            mau, obj.get_trang_thai_display(),
        )

    @admin.action(description="Duyệt và xuất bản các bài đã chọn")
    def duyet_hang_loat(self, request, queryset):
        so_luong = queryset.update(trang_thai="xuat_ban")
        self.message_user(request, f"Đã xuất bản {so_luong} bài viết.")

# blog/forms.py
from django import forms
from django.core.exceptions import ValidationError
from .models import BaiViet


class BaiVietForm(forms.ModelForm):
    class Meta:
        model = BaiViet
        fields = ["tieu_de", "tom_tat", "noi_dung", "danh_muc", "the", "trang_thai"]
        widgets = {
            "tom_tat": forms.Textarea(attrs={"rows": 3, "maxlength": 500}),
            "noi_dung": forms.Textarea(attrs={"rows": 20}),
        }
        help_texts = {"tom_tat": "Tối đa 500 ký tự, hiển thị ở trang danh sách."}

    def clean_tieu_de(self):
        tieu_de = self.cleaned_data["tieu_de"].strip()
        if len(tieu_de) < 10:
            raise ValidationError("Tiêu đề phải có ít nhất 10 ký tự.")
        return tieu_de

    def clean(self):
        du_lieu = super().clean()
        if du_lieu.get("trang_thai") == "xuat_ban" and not du_lieu.get("tom_tat"):
            self.add_error("tom_tat", "Bài xuất bản phải có tóm tắt.")
        return du_lieu

from django.views.generic import ListView, DetailView, CreateView, UpdateView
from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
from django.urls import reverse_lazy


class DanhSachBaiVietView(ListView):
    model = BaiViet
    template_name = "blog/danh_sach.html"
    context_object_name = "bai_viet"
    paginate_by = 12

    def get_queryset(self):
        qs = BaiViet.objects.filter(trang_thai="xuat_ban").select_related("tac_gia", "danh_muc")
        if danh_muc := self.request.GET.get("danh_muc"):
            qs = qs.filter(danh_muc__slug=danh_muc)
        if tu_khoa := self.request.GET.get("q"):
            qs = qs.filter(tieu_de__icontains=tu_khoa)
        return qs


class TaoBaiVietView(LoginRequiredMixin, CreateView):
    model = BaiViet
    form_class = BaiVietForm
    template_name = "blog/form.html"
    success_url = reverse_lazy("blog:danh_sach")

    def form_valid(self, form):
        form.instance.tac_gia = self.request.user
        return super().form_valid(form)

# blog/serializers.py
from rest_framework import serializers
from .models import BaiViet, DanhMuc


class DanhMucSerializer(serializers.ModelSerializer):
    so_bai_viet = serializers.IntegerField(read_only=True)

    class Meta:
        model = DanhMuc
        fields = ["id", "ten", "slug", "so_bai_viet"]


class BaiVietListSerializer(serializers.ModelSerializer):
    tac_gia_ten = serializers.CharField(source="tac_gia.username", read_only=True)
    danh_muc_ten = serializers.CharField(source="danh_muc.ten", read_only=True, default=None)

    class Meta:
        model = BaiViet
        fields = ["id", "tieu_de", "slug", "tom_tat", "tac_gia_ten",
                  "danh_muc_ten", "luot_xem", "ngay_xuat_ban"]


class BaiVietDetailSerializer(serializers.ModelSerializer):
    tac_gia = serializers.StringRelatedField(read_only=True)
    danh_muc = DanhMucSerializer(read_only=True)
    danh_muc_id = serializers.PrimaryKeyRelatedField(
        queryset=DanhMuc.objects.all(), source="danh_muc", write_only=True,
        required=False, allow_null=True,
    )

    class Meta:
        model = BaiViet
        fields = ["id", "tieu_de", "slug", "tom_tat", "noi_dung",
                  "tac_gia", "danh_muc", "danh_muc_id", "the",
                  "trang_thai", "luot_xem", "ngay_tao", "ngay_xuat_ban"]
        read_only_fields = ["slug", "luot_xem", "ngay_tao", "ngay_xuat_ban"]

    def validate_tieu_de(self, value):
        if len(value.strip()) < 10:
            raise serializers.ValidationError("Tiêu đề phải có ít nhất 10 ký tự.")
        return value.strip()

# blog/api_views.py
from django.db.models import Count, Q
from rest_framework import viewsets, filters, permissions, status
from rest_framework.decorators import action
from rest_framework.response import Response
from django_filters.rest_framework import DjangoFilterBackend
from django.db.models import F

from .models import BaiViet, DanhMuc
from .serializers import BaiVietListSerializer, BaiVietDetailSerializer, DanhMucSerializer


class BaiVietViewSet(viewsets.ModelViewSet):
    queryset = (
        BaiViet.objects
        .select_related("tac_gia", "danh_muc")
        .prefetch_related("the")
    )
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ["trang_thai", "danh_muc"]
    search_fields = ["tieu_de", "tom_tat", "noi_dung"]
    ordering_fields = ["ngay_tao", "luot_xem"]
    ordering = ["-ngay_tao"]
    lookup_field = "slug"

    def get_serializer_class(self):
        if self.action == "list":
            return BaiVietListSerializer
        return BaiVietDetailSerializer

    def get_permissions(self):
        if self.action in ("list", "retrieve"):
            return [permissions.AllowAny()]
        return [permissions.IsAuthenticated()]

    def perform_create(self, serializer):
        serializer.save(tac_gia=self.request.user)

    @action(detail=True, methods=["post"], permission_classes=[permissions.AllowAny])
    def tang_luot_xem(self, request, slug=None):
        BaiViet.objects.filter(slug=slug).update(luot_xem=F("luot_xem") + 1)
        bai_viet = self.get_object()
        return Response({"luot_xem": bai_viet.luot_xem}, status=status.HTTP_200_OK)


class DanhMucViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = DanhMuc.objects.annotate(so_bai_viet=Count("bai_viet", filter=Q(bai_viet__trang_thai="xuat_ban")))
    serializer_class = DanhMucSerializer
    lookup_field = "slug"

# blog/api_urls.py
from rest_framework.routers import DefaultRouter
from .api_views import BaiVietViewSet, DanhMucViewSet

router = DefaultRouter()
router.register("bai-viet", BaiVietViewSet, basename="bai-viet")
router.register("danh-muc", DanhMucViewSet, basename="danh-muc")

urlpatterns = router.urls

REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": [
        "rest_framework_simplejwt.authentication.JWTAuthentication",
        "rest_framework.authentication.SessionAuthentication",
    ],
    "DEFAULT_PERMISSION_CLASSES": [
        "rest_framework.permissions.IsAuthenticatedOrReadOnly",
    ],
    "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
    "PAGE_SIZE": 20,
    "DEFAULT_THROTTLE_CLASSES": [
        "rest_framework.throttling.AnonRateThrottle",
        "rest_framework.throttling.UserRateThrottle",
    ],
    "DEFAULT_THROTTLE_RATES": {"anon": "60/min", "user": "2000/hour"},
    "DEFAULT_FILTER_BACKENDS": ["django_filters.rest_framework.DjangoFilterBackend"],
}

# blog/tests/test_api.py
from django.test import TestCase
from django.urls import reverse
from django.contrib.auth.models import User
from rest_framework.test import APIClient

from blog.models import BaiViet


class BaiVietAPITest(TestCase):
    def setUp(self):
        self.client = APIClient()
        self.user = User.objects.create_user("minh", password="matkhau123")
        self.bai_viet = BaiViet.objects.create(
            tieu_de="Hướng dẫn Django cơ bản",
            noi_dung="Nội dung...",
            tac_gia=self.user,
            trang_thai="xuat_ban",
        )

    def test_danh_sach_khong_can_dang_nhap(self):
        r = self.client.get(reverse("bai-viet-list"))
        self.assertEqual(r.status_code, 200)
        self.assertEqual(r.data["count"], 1)

    def test_tao_bai_viet_can_dang_nhap(self):
        r = self.client.post(reverse("bai-viet-list"), {"tieu_de": "Bài mới"})
        self.assertEqual(r.status_code, 401)

    def test_tao_bai_viet_thanh_cong(self):
        self.client.force_authenticate(self.user)
        r = self.client.post(reverse("bai-viet-list"), {
            "tieu_de": "Bài viết hoàn toàn mới",
            "noi_dung": "Nội dung",
            "trang_thai": "nhap",
        })
        self.assertEqual(r.status_code, 201)
        self.assertEqual(r.data["tac_gia"]["id"], self.user.id)

    def test_tieu_de_qua_ngan(self):
        self.client.force_authenticate(self.user)
        r = self.client.post(reverse("bai-viet-list"), {"tieu_de": "Ngắn"})
        self.assertEqual(r.status_code, 400)
        self.assertIn("tieu_de", r.data)

    def test_tang_luot_xem(self):
        url = reverse("bai-viet-tang-luot-xem", kwargs={"slug": self.bai_viet.slug})
        self.client.post(url)
        self.client.post(url)
        self.bai_viet.refresh_from_db()
        self.assertEqual(self.bai_viet.luot_xem, 2)

# ❌ N+1: 1 query lấy 100 bài + 100 query lấy tác giả = 101 query
for bv in BaiViet.objects.all():
    print(bv.tac_gia.username)          # mỗi lần là 1 query!

# ✅ 1 query duy nhất với JOIN
for bv in BaiViet.objects.select_related("tac_gia", "danh_muc"):
    print(bv.tac_gia.username)

# ❌ N+1 với ManyToMany: 1 + 100 query
for bv in BaiViet.objects.all():
    print([t.ten for t in bv.the.all()])

# ✅ prefetch_related: 2 query tổng cộng
for bv in BaiViet.objects.prefetch_related("the"):
    print([t.ten for t in bv.the.all()])

# Cài django-debug-toolbar hoặc dùng assertNumQueries trong test
from django.test.utils import CaptureQueriesContext
from django.db import connection

with CaptureQueriesContext(connection) as ctx:
    list(BaiViet.objects.select_related("tac_gia").all()[:20])
    print(f"Số query: {len(ctx)}")       # phải là 1, không phải 21

from django.core.cache import cache
from django.views.decorators.cache import cache_page


@cache_page(60 * 15)                      # cache view 15 phút
def danh_sach_bai_viet(request):
    ...


def lay_bai_viet_noi_bat():
    khoa = "bai_viet_noi_bat"
    du_lieu = cache.get(khoa)
    if du_lieu is None:
        du_lieu = list(BaiViet.objects.filter(trang_thai="xuat_ban").order_by("-luot_xem")[:10])
        cache.set(khoa, du_lieu, timeout=300)
    return du_lieu

# config/celery.py
import os
from celery import Celery

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
app = Celery("config")
app.config_from_object("django.conf:settings", namespace="CELERY")
app.autodiscover_tasks()

# blog/tasks.py
from celery import shared_task
from django.core.mail import send_mail
from django.utils import timezone
from datetime import timedelta


@shared_task(bind=True, max_retries=3, default_retry_delay=60)
def gui_email_thong_bao(self, bai_viet_id: int):
    from .models import BaiViet
    try:
        bv = BaiViet.objects.select_related("tac_gia").get(pk=bai_viet_id)
        send_mail(
            subject=f"Bài viết đã xuất bản: {bv.tieu_de}",
            message=f"Bài viết của bạn đã được xuất bản: {bv.get_absolute_url()}",
            from_email="noreply@example.com",
            recipient_list=[bv.tac_gia.email],
            fail_silently=False,
        )
        return f"Đã gửi email cho {bv.tac_gia.email}"
    except Exception as exc:
        raise self.retry(exc=exc)


@shared_task
def don_dep_ban_nhap_cu():
    """Xoá bản nháp không cập nhật trong 90 ngày."""
    from .models import BaiViet
    han = timezone.now() - timedelta(days=90)
    so_luong, _ = BaiViet.objects.filter(trang_thai="nhap", ngay_cap_nhat__lt=han).delete()
    return f"Đã xoá {so_luong} bản nháp cũ"

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent

SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]       # bắt buộc, không có mặc định
DEBUG = os.environ.get("DJANGO_DEBUG", "False") == "True"
ALLOWED_HOSTS = os.environ.get("DJANGO_ALLOWED_HOSTS", "").split(",")

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": os.environ["POSTGRES_DB"],
        "USER": os.environ["POSTGRES_USER"],
        "PASSWORD": os.environ["POSTGRES_PASSWORD"],
        "HOST": os.environ.get("POSTGRES_HOST", "db"),
        "PORT": os.environ.get("POSTGRES_PORT", "5432"),
        "CONN_MAX_AGE": 60,                  # tái sử dụng kết nối
        "OPTIONS": {"connect_timeout": 10},
    }
}

# Bảo mật production — bật hết
SECURE_SSL_REDIRECT = not DEBUG
SESSION_COOKIE_SECURE = not DEBUG
CSRF_COOKIE_SECURE = not DEBUG
SECURE_HSTS_SECONDS = 31536000 if not DEBUG else 0
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = "DENY"

CSRF_TRUSTED_ORIGINS = os.environ.get("CSRF_TRUSTED_ORIGINS", "").split(",")

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": os.environ.get("REDIS_URL", "redis://localhost:6379/1"),
    }
}

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "day_du": {"format": "{asctime} | {levelname:<8} | {name} | {message}", "style": "{"},
    },
    "handlers": {
        "console": {"class": "logging.StreamHandler", "formatter": "day_du"},
    },
    "root": {"handlers": ["console"], "level": "INFO"},
}

>>> from blog.models import BaiViet
>>> from django.db import connection, reset_queries
>>> from django.conf import settings
>>> settings.DEBUG = True

>>> # Đếm số query của một đoạn code
>>> reset_queries()
>>> ds = list(BaiViet.objects.filter(trang_thai="xuat_ban"))
>>> [(b.tieu_de, b.tac_gia.username) for b in ds]
>>> print(f"Số query: {len(connection.queries)}")

>>> # Xem SQL thật
>>> print(BaiViet.objects.filter(trang_thai="xuat_ban").query)

>>> # Kiểm tra dữ liệu bẩn
>>> BaiViet.objects.filter(tom_tat="").count()
>>> BaiViet.objects.filter(ngay_xuat_ban__gt=timezone.now()).count()

# settings.py (chỉ bật khi DEBUG)
if DEBUG:
    INSTALLED_APPS += ["debug_toolbar"]
    MIDDLEWARE.insert(0, "debug_toolbar.middleware.DebugToolbarMiddleware")
    INTERNAL_IPS = ["127.0.0.1"]

# urls.py
if settings.DEBUG:
    import debug_toolbar
    urlpatterns += [path("__debug__/", include(debug_toolbar.urls))]

import logging

logger = logging.getLogger(__name__)


def xuat_ban_bai_viet(bai_viet_id: int) -> bool:
    from .models import BaiViet

    logger.info("Bắt đầu xuất bản bài viết id=%s", bai_viet_id)

    try:
        bv = BaiViet.objects.get(pk=bai_viet_id)
    except BaiViet.DoesNotExist:
        logger.warning("Không tìm thấy bài viết id=%s", bai_viet_id)
        return False

    if bv.trang_thai == "xuat_ban":
        logger.info("Bài viết id=%s đã xuất bản trước đó, bỏ qua", bai_viet_id)
        return True

    try:
        with transaction.atomic():
            bv.trang_thai = "xuat_ban"
            bv.ngay_xuat_ban = timezone.now()
            bv.save(update_fields=["trang_thai", "ngay_xuat_ban"])
    except Exception:
        logger.exception("Lỗi khi xuất bản bài viết id=%s", bai_viet_id)
        raise

    logger.info("Đã xuất bản bài viết id=%s", bai_viet_id)
    return True

# settings.py
import os
from pathlib import Path

def env_bool(ten: str, mac_dinh: bool = False) -> bool:
    return os.environ.get(ten, str(mac_dinh)).lower() in ("1", "true", "yes", "on")


def env_list(ten: str, mac_dinh: list[str] | None = None) -> list[str]:
    gia_tri = os.environ.get(ten, "")
    return [x.strip() for x in gia_tri.split(",") if x.strip()] or (mac_dinh or [])


SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
DEBUG = env_bool("DJANGO_DEBUG")
ALLOWED_HOSTS = env_list("DJANGO_ALLOWED_HOSTS", ["localhost"])
CSRF_TRUSTED_ORIGINS = env_list("CSRF_TRUSTED_ORIGINS")

if not DEBUG and SECRET_KEY.startswith("django-insecure"):
    raise RuntimeError("SECRET_KEY không an toàn đang được dùng ở production!")

STATIC_URL = "/static/"
STATIC_ROOT = BASE_DIR / "staticfiles"
STATICFILES_DIRS = [BASE_DIR / "static"]

MEDIA_URL = "/media/"
MEDIA_ROOT = BASE_DIR / "media"

STORAGES = {
    "default": {"BACKEND": "django.core.files.storage.FileSystemStorage"},
    "staticfiles": {"BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage"},
}