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


class TimeStampedModel(models.Model):
    """Abstract class"""
    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)
    
    class Meta:
        abstract = True

# rooms/models.py
from django.db import models
from apps.core.models import TimeStampedModel


class AbstractItem(TimeStampedModel):
    """Abstract class from TimeStampedModel"""
    name = models.CharField(max_length=80)
    
    class Meta:
        abstract = True

    def __str__(self):
        return self.name


class RoomType(AbstractItem):
    """Room model: RoomType"""
    class Meta:
        verbose_name = 'Room Type'
        ordering = ['name']


class Amenity(AbstractItem):
    """Room model: Amenity"""
    class Meta:
        verbose_name_plural = 'Amenities'


class Facility(AbstractItem):
    """Room model: Facility"""
    class Meta:
        verbose_name_plural = 'Facilities'

...
>>> queryset = Post.objects.filter(pub_date__lte=timezone.now())
>>> str(queryset.query)
SELECT "post"."id", "post"."author", "post"."title", "post"."content", "post"."created_date", "post"."pub_date" FROM "post" WHERE "post"."pub_date" <= "2022-10-23 15:24:27"

>>> Post.objects.order_by('created_date')  # ASCENDING
>>> Post.objects.order_by('-created_date')  # DESCENDING

>>> Post.objects.filter(pub_date__lte=timezone.now()).order_by('created_date')

# apps/posts/views.py

from django.shortcuts import render
from django.utils import timezone
from .models import Post


def post_list(request):
    posts = Post.objects.filter(pub_date__lte=timezone.now()).order_by('created_date')
    return render(request, 'post_list.html', {'posts': posts})

# apps/reviews/models.py

from django.db import models
from django.utils import timezone


class PublishedManager(models.Manager):
    """Custom manager for published"""

    use_for_related_fields = True

    def published(self, **kwargs):
        return self.filter(pub_date__lte=timezone.now(), **kwargs)


class FlavorReview(models.Model):
    """Ice cream flavor review model"""

    review = models.CharField(max_length=255)
    pub_date = models.DateTimeField()

    # Set default manager to custom manager
    objects = PublishedManager()

>>> from reviews.models import FlavorReview
>>> FlavorReview.objects.count()  # 저장된 모든 평가 개수 조회
35
>>> FlavorReview.objects.published().count()  # 퍼블리시된 평가 개수 조회
31

# apps/reviews/models.py

from django.db import models
from django.utils import timezone


class PublishedReviewManager(models.Manager):
    """Custom manager for pub_date"""

    use_for_related_fields = True

    def get_queryset(self):
        return super().get_queryset().filter(pub_date__lte=timezone.now())


class FlavorReview(models.Model):
    """Ice cream flavor review model"""

    review = models.CharField(max_length=255)
    pub_date = models.DateTimeField()

    # Set managers
    objects = models.Manager()
    published_objects = PublishedReviewManager()
    
    class Meta:
        default_manager_name = 'objects'

# apps/ice_creams/models.py

from django.db import models


class IceCreamQuerySet(models.QuerySet):
    def flavor_by(self, flavor: str = None):
        if flavor is None:
            flavor = 'VANILLA'
        return self.filter(flavor=flavor)
    
    def get_active_icecreams(self):
        return self.filter(active=True)


class IceCreamManager(models.Manager):
    def get_queryset(self):
        return IceCreamQuerySet(self.model, using=self._db)
    
    def flavor_by(self, flavor):
        return self.get_queryset().flavor_by(flavor=flavor)
    
    def get_active_icecreams(self):
        return self.get_queryset().get_active_icecreams()


class IceCream(models.Model):
    FLAVORS = (
        ('VANILLA', 'Vanilla'),
        ('CHOCOLATE', 'Chocolate'),
        ('STRAWBERRY', 'Strawberry'),
    )
    
    flavor = models.CharField(max_length=20, choices=FLAVORS, default='VANILLA')
    active = models.BooleanField(default=True)
    
    objects = models.Manager()
    icecreams = IceCreamManager()
    
    class Meta:
        default_manager_name = 'objects'

# apps/ice_creams/models.py

from django.db import models


class IceCreamQuerySet(models.QuerySet):
    def flavor_by(self, flavor: str = None):
        if flavor is None:
            flavor = 'VANILLA'
        return self.filter(flavor=flavor)
    
    def get_active_icecreams(self):
        return self.filter(active=True)


class IceCream(models.Model):
    FLAVORS = (
        ('VANILLA', 'Vanilla'),
        ('CHOCOLATE', 'Chocolate'),
        ('STRAWBERRY', 'Strawberry'),
    )
    
    flavor = models.CharField(max_length=20, choices=FLAVORS, default='VANILLA')
    active = models.BooleanField(default=True)
    
    objects = models.Manager()
    icecreams = IceCreamQuerySet.as_manager()
    
    class Meta:
        default_manager_name = 'objects'

# apps/ice_creams/models.py

from django.db import models


class IceCreamQuerySet(models.QuerySet):
    def flavor_by(self, flavor: str = None):
        if flavor is None:
            flavor = 'VANILLA'
        return self.filter(flavor=flavor)
    
    def get_active_icecreams(self):
        return self.filter(active=True)


class IceCreamCustomManager(models.Manager):
    def manager_only_method(self):
        # do something
        return


class IceCream(models.Model):
    FLAVORS = (
        ('VANILLA', 'Vanilla'),
        ('CHOCOLATE', 'Chocolate'),
        ('STRAWBERRY', 'Strawberry'),
    )
    
    flavor = models.CharField(max_length=20, choices=FLAVORS, default='VANILLA')
    active = models.BooleanField(default=True)
    
    objects = models.Manager()
    icecreams = IceCreamCustomManager.from_queryset(IceCreamQuerySet)()
    
    class Meta:
        default_manager_name = 'objects'

from django.core.exceptions import ObjectDoesNotExist

from flavors.models import Flavor
from store.exceptions import OutOfStock


def list_flavor_line_item(sku):
    try:
        return Flavor.objects.get(sku=sku, quantity__gt=0)
    except Flavor.DoesNotExist:
        msg = "We are out of {0}".format(sku)
        raise OutOfStock(msg)


def list_any_line_item(model, sku):
    try:
        return model.objects.get(sku=sku, quantity__gt=0)
    except ObjectDoesNotExist:
        msg = "We are out of {0}".format(sku)
        raise OutOfStock(msg)

# Bad case
from django.db.models import Q

from promos.models import Promo


def fun_function(**kwargs):
    """유효한 아이스크림 프로모션 찾기"""
    # 너무 길게 작성된 쿼리 체인은 좋지 않음
    return Promo.objects.active().filter(Q(name__startswith=name) |
                                         Q(description__icontains=name))

# Advanced
from django.db.models import Q

from promos.models import Promo


def fun_function(**kwargs):
    """유효한 아이스크림 프로모션 찾기"""
    # 필터 체이닝을 여러 줄로 분할하여 가독성을 높임
    results = Promo.objects.active()
    results = results.filter(
        Q(name__startswith=name) |
        Q(description__icontains=name)
    )
    results = results.exclude(status='melted')
    results = results.select_related('flavors')
    return results

from promos.models import Promo


def fun_function():
    # 쿼리셋 생성시에 SQL 실행되지 않음
    results = Promo.objects.active()
    
    # 실제 필요로 하는 시점에(iteration) 실행됨
    for item in results:
        print(f'[프로모션명] {item.name}')

# 방문한 모든 고객 중
# 한 번 방문할 때마다 평균 한 주걱 이상의 아이스크림을 주문한 모든 고객 목록
# scoops_ordered(주문횟수), store_visits(방문횟수)

from models.customers import Customer


customers = []
for customer in Customer.objects.iterate():
    if customer.scoops_ordered > customer.store_visits:
        customers.append(customer)

from django.db.models import F
from models.customers import Customer


customers = Customer.objects.filter(scoops_ordered__gt=F('store_visits'))

# settings/base.py

DATABASES = {
    'default': {
        # ...
        'ATOMIC_REQUESTS': True,
    },
}

# flavors/views.py
from django.db import transaction
from django.http import HttpResponse
from django.shortcuts import get_object_or_404
from django.utils import timezone

from .models import Flavor


@transaction.non_atomic_requests
def posting_flavor_status(request, pk, status):
    flavor = get_object_or_404(Flavor, pk=pk)  # 단일 객체 쿼리셋 가져오기

    # 여기서는 오토커밋 모드 실행
    flavor.latest_status_change_attempt = timezone.now()  # 최신상태 변경 시도
    flavor.save()
    
    with transaction.atomic():
        # 트랜잭션 안에서 실행
        # 함수 뷰 자체는 예외적으로 트랜잭션이 아니고, 이곳 with 블록만 트랜잭션 처리됨!!
        flavor.status = status
        flavor.latest_status_change_success = timezone.now()  # 최신상태 변경 성공
        flavor.save()
        return HttpResponse('Hooray!')
    
    return HttpResponse('Sadness', status=400)

# tastings/urls.py
from django.conf.urls import url

from .views import TasteListView, TasteDetailView, TasteResultsView, TasteUpdateView


urlpatterns = [
    url(
        regex=r'^$',
        view=TasteListView.as_view(),
        name='list',
    ),
    url(
        regex=r'^(?P<pk>\d+)/$',
        view=TasteDetailView.as_view(),
        name='detail',
    ),
    url(
        regex=r'^(?P<pk>\d+)/results/$',
        view=TasteResultsView.as_view(),
        name='results',
    ),
    url(
        regex=r'^(?P<pk>\d+)/update/$',
        view=TasteUpdateView.as_view(),
        name='update',
    )
]

# Mixin inheritance example - Add attribute to context
from django.views.generic import TemplateView


class FreshFruitMixin(object):
    def get_context_data(self, **kwargs):
        context = super(FreshFruitMixin, self).get_context_data(**kwargs)
        context['has_fresh_fruit'] = True
        return context


class FruityFlavorView(FreshFruitMixin, TemplateView):
    template_name = 'fruity_flavor.html'

# flavors/views.py
from django.views.generic import DetailView

from django.contrib.auth.mixins import LoginRequiredMixin

from .models import Flavor


class FlavorDetailView(LoginRequiredMixin, DetailView):
    model = Flavor

# flavors/views.py
from django.views.generic import CreateView

from django.contrib.auth.mixins import LoginRequiredMixin

from .models import Flavor


class FlavorCreateView(LoginRequiredMixin, CreateView):
    model = Flavor
    fields = ('title', 'slug', 'scoops_remaining')
    
    def form_valid(self, form):
        # Custom logic is here
        # This method returns django.http.HttpResponseRedirect
        return super(FlavorCreateView, self).form_valid(form)
    
    def form_invalid(self, form):
        # Custom logic is here
        # This method returns django.http.HttpResponse
        return super(FlavorCreateView, self).form_invalid(form)

from django.views.generic import ListView

from .models import Flavor


class FlavorListView(ListView):
    model = Flavor
    
    def get_queryset(self):
        qs = super(FlavorListView, self).get_queryset()
        
        # GET 메서드로 q 파라미터 받기
        q = self.request.GET.get('q')
        if q:
            return qs.filter(title__icontains=q)
        return qs

from django.http import HttpResponse
from django.shortcuts import get_object_or_404

from django.views.generic import View

from django.contrib.auth.mixins import LoginRequiredMixin

from .models import Flavor
from .reports import make_flavor_pdf


class PDFFlavorView(LoginRequiredMixin, View):
    def get(self, request, *args, **kwargs):
        flavor = get_object_or_404(Flavor, slug=kwargs['slug'])
        response = HttpResponse(content_type='application/pdf')
        response = make_flavor_pdf(response, flavor)
        return response

import csv
import StringIO

from django import forms

from .models import Purchase, Seller


class PurchaseForm(forms.ModelForm):
    class Meta:
        model = Purchase
    
    def clean_seller(self):
        """Check if inserted seller exists"""
        seller = self.cleaned_data['seller']
        try:
            Seller.objects.get(name=seller)
        except Seller.DoesNotExist:
            msg = f'{seller} does not exist in purchase #{self.cleaned_data["purchase_number"]}'
            raise forms.ValidationError(msg)
        return seller


def add_csv_purchases(rows):
    rows = StringIO.StringIO(rows)
    records_added = 0
    errors = []
    for row in csv.DictReader(rows, delimiter=','):
        form = PurchaseForm(row)
        if form.is_valid():  # validation point
            form.save()
            records_added += 1
        else:
            errors.append(form.errors)
    return records_added, errors

# apps/tasters/forms.py
from django import forms

from .models import Taster


class TasterForm(forms.ModelForm):
    class Meta:
        model = Taster
    
    def __init__(self, *args, **kwargs):
        self.user = kwargs.pop('user')  # Add new value to ModelForm class
        super(TasterForm, self).__init__(*args, **kwargs)

# apps/tasters/views.py
from django.views.generic import UpdateView

from django.contrib.auth.mixins import LoginRequiredMixin

from .forms import TasterForm
from .models import Taster


class TasterUpdateView(LoginRequiredMixin, UpdateView):
    model = Taster
    form_class = TasterForm
    success_url = '/someplace/'
    
    def get_form_kwargs(self):
        """폼에 추가할 키워드 인자들을 반환하는 메서드"""
        kwargs = super(TasterUpdateView, self).get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs

from django.shortcuts import redirect, reverse
from django.views.generic import FormView

from django.contrib.auth.mixins import LoginRequiredMixin

from .forms import TasterForm
from .models import Taster


class CreateTasterView(LoginRequiredMixin, FormView):
    form_class = TasterForm
    template_name = 'tasters/create.html'

    def post(self, request, *args, **kwargs):
        # a. 모델폼 인스턴스 생성 이후 유효성 검사
        form = TasterForm(request.POST)
        if form.is_valid():
            # b. 모델 인스턴스 생성, commit 값이 False 인 경우 DB 까지 저장되지 않고 모델 객체 반환
            taster = form.save(commit=False)
            taster.ip = request.META['REMOTE_ADDR']  # 접속 IP 세팅
            taster.save()  # Model Save!
            taster.save_m2m()
            return redirect(reverse('tasters:detail', kwargs={'pk': taster.pk}))

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


class ModelFormFailureHistory(models.Model):
    """모델폼 실패기록 저장 모델"""
    form_data = models.TextField()
    model_data = models.TextField()

# flavors/views.py
import json

from django.contrib import messages
from django.core import serializers
from core.models import ModelFormFailureHistory


class FlavorActionMixin(object):
    @property
    def success_msg(self):
        return NotImplemented

    def form_valid(self, form):
        messages.info(self.request, self.success_msg)
        return super(FlavorActionMixin, self).form_valid(form)

    def form_invalid(self, form):
        """유효성 검사 실패시 호출됨, 실패 기록 저장하는 로직 구현"""
        form_data = json.dumps(form.cleaned_data)
        model_data = serializers.serialize('json', [form.instance])[1:-1]
        ModelFormFailureHistory.objects.create(
            form_data=form_data,
            model_data=model_data,
        )
        return super(FlavorActionMixin, self).form_invalid(form)

# flavors/views.py
from django.views.generic import CreateView, UpdateView

from django.contrib.auth.mixins import LoginRequiredMixin

from .models import Flavor


class FlavorCreateView(LoginRequiredMixin, CreateView):
    model = Flavor
    fields = ('title', 'slug', 'scoops_remaining')


class FlavorUpdateView(LoginRequiredMixin, UpdateView):
    model = Flavor
    fields = ('title', 'slug', 'scoops_remaining')

# core/validators.py
from django.core.exceptions import ValidationError


def validate_tasty(value):
    if not value.startswith(u'Tasty'):
        msg = u'Must start with "Tasty"'
        raise ValidationError(msg)

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

from .validators import validate_tasty


class TastyTitleAbstractModel(models.Model):
    title = models.CharField(max_length=255, validators=[validate_tasty])
    
    class Meta:
        abstract = True

# flavors/models.py
from django.urls import reverse
from django.db import models

from core.models import TastyTitleAbstractModel


class Flavor(TastyTitleAbstractModel):
    slug = models.SlugField()
    scoops_remaining = models.IntegerField(default=0)

    def get_absolute_url(self):
        return reverse('flavors:detail', kwargs={'slug': self.slug})

# flavors/forms.py
from django import forms

from core.validators import validate_tasty
from .models import Flavor


class FlavorForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super(FlavorForm, self).__init__(*args, **kwargs)
        self.fields['title'].validators.append(validate_tasty)
        self.fields['slug'].validators.append(validate_tasty)
    
    class Meta:
        model = Flavor

# flavors/views.py
from django.contrib import messages
from django.views.generic import CreateView

from django.contrib.auth.mixins import LoginRequiredMixin

from .models import Flavor
from .forms import FlavorForm  # 커스텀 모델폼


class FlavorActionMixin(object):
    model = Flavor
    fields = ('title', 'slug', 'scoops_remaining')
    
    @property
    def success_msg(self):
        return NotImplemented
    
    def form_valid(self, form):
        messages.info(self.request, self.success_msg)
        return super(FlavorActionMixin, self).form_valid(form)


class FlavorCreateView(LoginRequiredMixin, FlavorActionMixin, CreateView):
    success_msg = 'created.'
    form_class = FlavorForm  # 클래스 기반 뷰의 모델폼을 커스텀 모델폼으로 명시적 적용

# flavors/forms.py
from django import forms
from flavors.models import Flavor


class IceCreamOrderForm(forms.Form):
    slug = forms.ChoiceField('Flavor')
    toppings = forms.CharField()
    
    def __init__(self, *args, **kwargs):
        super(IceCreamOrderForm, self).__init__(*args, **kwargs)

        # slug 필드의 선택 가능 옵션들(choices)은 여기서 지정함
        self.fields['slug'].choices = [
            (x.slug, x.title) for x in Flavor.objects.all()
        ]
    
    # clean_<field> 형태의 커스텀 유효성 검사 메서드
    def clean_slug(self):
        slug = self.cleaned_data['slug']
        if Flavor.objects.get(slug=slug).scoops_remaining <= 0:
            msg = u'Sorry, we are out of that flavor.'
            raise forms.ValidationError(msg)
        return slug

...

    def clean():
        cleaned_data = super(IceCreamOrderForm, self).clean()
        
        # additional validation
        slug = cleaned_data.get('slug', '')
        toppings = cleaned_data.get('toppings', '')
        if u'chocolate' in slug.lower() or u'chocolate' in toppings.lower():
            msg = u'Your order has too much chocolate'
            raise forms.ValidationError(msg)
        return cleaned_data

# stores/models.py
from django.urls import reverse
from django.db import models


class IceCreamStore(models.Model):
    title = models.CharField(max_length=100)
    block_address = models.TextField()
    phone = models.CharField(max_length=20, blank=True)
    description = models.TextField(blank=True)
    
    def get_absolute_url(self):
        return reverse('stores:detail', kwargs={ 'pk': self.pk })

# stores/form.py
from django import forms

from .models import IceCreamStore


class IceCreamStoreCreateForm(forms.ModelForm):
    
    class Meta:
        model = IceCreamStore

        # Set mandatory fields in ModelForm
        fields = ( 'title', 'block_address', )


class IceCreamStoreUpdateForm(IceCreamStoreCreateForm):
        
    def __init__(self, *args, **kwargs):
        # 지정한 모델 기반으로 부모 클래스인 생성폼에서 우선 초기화
        super(IceCreamStoreUpdateForm, self).__init__(*args, **kwargs)

        # 이후 모델폼 내 유사 딕셔너리 객체인 fields 속성을 통해 모델에서 원하는 필드값의 속성 변경
        self.fields['phone'].required = True
        self.fields['description'].required = True
    
    class Meta(IceCreamStoreCreateForm.Meta):
        # Set all fields in ModelForm
        fields = ( 'title', 'block_address', 'phone', 'description', )

# stores/views.py
from django.views.generic import CreateView, UpdateView

from .forms import IceCreamStoreCreateForm, IceCreamStoreUpdateForm
from .models import IceCreamStore


class IceCreamCreateView(CreateView):
    model = IceCreamStore
    form_class = IceCreamStoreCreateForm


class IceCreamUpdateView(UpdateView):
    model = IceCreamStore
    form_class = IceCreamStoreUpdateForm

# core/views.py
class TitleSearchMixin(object):
    
    def get_queryset(self):
        queryset = super(TitleSearchMixin, self).get_queryset()
        
        # 검색어가 존재하면 필터된 쿼리셋 반환
        q = self.request.GET.get('q')
        if q:
            return queryset.filter(title__icontains=q)
        return queryset

# flavors/views.py
from django.views.generic import ListView

from core.views import TitleSearchMixin
from .models import Flavor


class FlavorListView(TitleSearchMixin, ListView):
    model = Flavor

# stores/views.py
from django.views.generic import ListView

from core.views import TitleSearchMixin
from .models import Store


class IceCreamStoreListView(TitleSearchMixin, ListView):
    model = Store