# 프로젝트 생성
django-admin startproject myproject

# 앱 생성
python manage.py startapp myapp

# 서버 실행
python manage.py runserver

# models.py
from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.name
        
    class Meta:
        ordering = ['-created_at']
        verbose_name = '사용자'
        verbose_name_plural = '사용자 목록'

# urls.py (프로젝트 레벨)
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('api.urls')),
    path('', include('myapp.urls')),
]

# urls.py (앱 레벨)
from django.urls import path
from . import views

app_name = 'myapp'  # URL 네임스페이스

urlpatterns = [
    path('users/', views.user_list, name='user_list'),
    path('users/<int:pk>/', views.user_detail, name='user_detail'),
    path('users/create/', views.user_create, name='user_create'),
    path('users/<int:pk>/update/', views.user_update, name='user_update'),
    path('users/<int:pk>/delete/', views.user_delete, name='user_delete'),
]

# views.py (함수 기반 뷰)
from django.shortcuts import render, get_object_or_404, redirect
from .models import User
from .forms import UserForm

def user_list(request):
    users = User.objects.all()
    return render(request, 'myapp/user_list.html', {'users': users})

def user_detail(request, pk):
    user = get_object_or_404(User, pk=pk)
    return render(request, 'myapp/user_detail.html', {'user': user})

# views.py (클래스 기반 뷰)
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.urls import reverse_lazy

class UserListView(ListView):
    model = User
    template_name = 'myapp/user_list.html'
    context_object_name = 'users'
    paginate_by = 10
    
class UserDetailView(DetailView):
    model = User
    template_name = 'myapp/user_detail.html'
    context_object_name = 'user'

# forms.py
from django import forms
from .models import User

class UserForm(forms.ModelForm):
    confirm_email = forms.EmailField(label='이메일 확인')
    
    class Meta:
        model = User
        fields = ['name', 'email']
        widgets = {
            'name': forms.TextInput(attrs={'class': 'form-control'}),
            'email': forms.EmailInput(attrs={'class': 'form-control'}),
        }
        help_texts = {
            'email': '유효한 이메일 주소를 입력하세요.',
        }
    
    def clean_email(self):
        email = self.cleaned_data['email']
        if User.objects.filter(email=email).exists():
            if self.instance.pk is None or self.instance.email != email:
                raise forms.ValidationError('이미 사용 중인 이메일입니다.')
        return email
    
    def clean(self):
        cleaned_data = super().clean()
        email = cleaned_data.get('email')
        confirm_email = cleaned_data.get('confirm_email')
        
        if email and confirm_email and email != confirm_email:
            self.add_error('confirm_email', '이메일 주소가 일치하지 않습니다.')
            
        return cleaned_data

# views.py (폼 사용)
def user_create(request):
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            user = form.save()
            return redirect('myapp:user_detail', pk=user.pk)
    else:
        form = UserForm()
    
    return render(request, 'myapp/user_form.html', {'form': form})

# settings.py
INSTALLED_APPS = [
    # ...
    'django.contrib.auth',
    'django.contrib.contenttypes',
    # ...
]

AUTH_USER_MODEL = 'myapp.CustomUser'

# models.py
from django.contrib.auth.models import AbstractUser, BaseUserManager, Permission
from django.db import models

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('이메일은 필수입니다')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user
        
    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        
        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractUser):
    username = None  # 기본 username 필드 제거
    email = models.EmailField('이메일 주소', unique=True)
    phone = models.CharField('전화번호', max_length=15, blank=True)
    
    USERNAME_FIELD = 'email'  # 로그인에 사용할 필드
    REQUIRED_FIELDS = []  # createsuperuser 명령 실행 시 요구하는 필드
    
    objects = CustomUserManager()
    
    def __str__(self):
        return self.email

# views.py (로그인과 로그아웃)
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect

def login_view(request):
    if request.method == 'POST':
        email = request.POST.get('email')
        password = request.POST.get('password')
        user = authenticate(request, email=email, password=password)
        
        if user is not None:
            login(request, user)
            return redirect('home')
        else:
            error_message = '이메일 또는 비밀번호가 올바르지 않습니다'
    
    return render(request, 'myapp/login.html', locals())

@login_required
def logout_view(request):
    logout(request)
    return redirect('login')

# permissions.py
from django.contrib.auth.mixins import UserPassesTestMixin, LoginRequiredMixin
from django.core.exceptions import PermissionDenied

class StaffRequiredMixin(UserPassesTestMixin):
    def test_func(self):
        return self.request.user.is_staff

# 함수 기반 뷰에서 권한 확인
from django.contrib.auth.decorators import login_required, permission_required

@login_required
def profile_view(request):
    return render(request, 'myapp/profile.html')

@permission_required('myapp.change_user')
def user_update(request, pk):
    # 사용자 업데이트 로직
    pass

# 클래스 기반 뷰에서 권한 확인
from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin

class UserUpdateView(LoginRequiredMixin, PermissionRequiredMixin, UpdateView):
    model = User
    form_class = UserForm
    template_name = 'myapp/user_form.html'
    permission_required = 'myapp.change_user'
    
    def get_success_url(self):
        return reverse_lazy('myapp:user_detail', kwargs={'pk': self.object.pk})

# settings.py
INSTALLED_APPS = [
    # ...
    'rest_framework',
    'django.contrib.staticfiles',
]

# REST Framework 설정
REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10,
}

# serializers.py
from rest_framework import serializers
from .models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'name', 'email', 'created_at']
        read_only_fields = ['created_at']
        
    def validate_email(self, value):
        if User.objects.filter(email=value).exists():
            if self.instance is None or self.instance.email != value:
                raise serializers.ValidationError('이미 사용 중인 이메일입니다.')
        return value

# views.py (API 뷰)
from rest_framework import viewsets, permissions, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from django.core.cache import cache
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [permissions.IsAuthenticated]
    filter_backends = [filters.SearchFilter, filters.OrderingFilter]
    search_fields = ['name', 'email']
    ordering_fields = ['name', 'created_at']
    
    @method_decorator(cache_page(60 * 15))  # 15분 캐시
    def list(self, request, *args, **kwargs):
        return super().list(request, *args, **kwargs)
    
    @action(detail=True, methods=['get'])
    def profile(self, request, pk=None):
        user = self.get_object()
        data = {
            'id': user.id,
            'name': user.name,
            'email': user.email,
            'created_at': user.created_at,
        }
        return Response(data)

# urls.py (API URL)
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from . import views

router = DefaultRouter()
router.register(r'users', views.UserViewSet)

urlpatterns = [
    path('', include(router.urls)),
    path('auth/', include('rest_framework.urls')),
]

# 저수준 캐시 API
from django.core.cache import cache

def get_active_users():
    # 캐시에서 데이터 가져오기 시도
    active_users = cache.get('active_users')
    
    if active_users is None:
        # 캐시에 없으면 데이터베이스에서 가져와 캐시에 저장
        active_users = User.objects.filter(is_active=True)
        cache.set('active_users', active_users, 60 * 5)  # 5분간 캐시
    
    return active_users

# 캐시 템플릿 조각
from django.core.cache import cache
from django.template.loader import render_to_string

def render_user_list():
    # 캐시된 HTML 조각 가져오기 시도
    fragment = cache.get('user_list_html')
    
    if fragment is None:
        users = User.objects.all()[:10]
        fragment = render_to_string('fragments/user_list.html', {'users': users})
        cache.set('user_list_html', fragment, 60 * 10)  # 10분간 캐시
    
    return fragment

# 뷰 레벨 캐시
from django.views.decorators.cache import cache_page

@cache_page(60 * 15)  # 15분 캐시
def cached_view(request):
    return render(request, 'cached_template.html')

# 비동기 작업 설정 (Celery)
# celery.py
import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

app = Celery('myproject')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

# tasks.py
from celery import shared_task
from django.core.mail import send_mail
from django.template.loader import render_to_string

@shared_task
def send_notification_email(user_id):
    from .models import User  # 순환 참조 방지를 위해 내부에서 임포트
    user = User.objects.get(id=user_id)
    
    context = {
        'user': user,
        'site_name': 'My Django Site',
    }
    
    html_message = render_to_string('emails/notification.html', context)
    plain_message = render_to_string('emails/notification.txt', context)
    
    send_mail(
        subject='새로운 알림',
        message=plain_message,
        from_email='[email protected]',
        recipient_list=[user.email],
        html_message=html_message,
        fail_silently=False,
    )
    
    return f"Notification sent to {user.email}"

# 관리자 인터페이스 설정
# admin.py
from django.contrib import admin
from django.utils.html import format_html
from .models import User

@admin.register(User)
class UserAdmin(admin.ModelAdmin):
    list_display = ['name', 'email', 'created_at', 'actions_buttons']
    list_filter = ['created_at', 'is_active']
    search_fields = ['name', 'email']
    readonly_fields = ['created_at']
    fieldsets = [
        (None, {'fields': ['name', 'email']}),
        ('추가 정보', {'fields': ['created_at'], 'classes': ['collapse']}),
    ]
    
    def actions_buttons(self, obj):
        return format_html(
            '<a class="button" href="{}">보기</a> '
            '<a class="button" onclick="return confirm(\'정말 이메일을 발송하시겠습니까?\');" href="{}">이메일 발송</a>',
            f'/admin/users/{obj.id}/view/',
            f'/admin/users/{obj.id}/send_email/'
        )
    actions_buttons.short_description = '작업'
    
    def send_notification(self, request, queryset):
        for user in queryset:
            send_notification_email.delay(user.id)
        self.message_user(request, f"{queryset.count()}명의 사용자에게 알림이 발송되었습니다.")
    send_notification.short_description = "선택한 사용자에게 알림 발송"
    
    actions = ['send_notification']

# admin_views.py
from django.contrib.admin.views.decorators import staff_member_required
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.urls import path
from django.contrib import messages

from .models import User
from .tasks import send_notification_email

@staff_member_required
def send_user_email(request, user_id):
    user = get_object_or_404(User, id=user_id)
    task = send_notification_email.delay(user.id)
    messages.success(request, f"{user.email}에게 알림 이메일을 발송 중입니다. 작업 ID: {task.id}")
    return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/admin/'))

# 관리자 URL 확장
class UserAdmin(admin.ModelAdmin):
    # ... 기존 코드 ...
    
    def get_urls(self):
        urls = super().get_urls()
        custom_urls = [
            path(
                '<int:user_id>/send_email/',
                self.admin_site.admin_view(send_user_email),
                name='user-send-email',
            ),
        ]
        return custom_urls + urls

# tests.py
from django.test import TestCase, Client
from django.urls import reverse
from .models import User

class UserModelTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(
            name="테스트 사용자",
            email="[email protected]"
        )
    
    def test_user_creation(self):
        self.assertEqual(self.user.name, "테스트 사용자")
        self.assertEqual(self.user.email, "[email protected]")
        self.assertTrue(isinstance(self.user, User))
    
    def test_str_representation(self):
        self.assertEqual(str(self.user), self.user.name)

class UserViewTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create(
            name="테스트 사용자",
            email="[email protected]"
        )
        self.list_url = reverse('myapp:user_list')
        self.detail_url = reverse('myapp:user_detail', args=[self.user.id])
    
    def test_user_list_view(self):
        response = self.client.get(self.list_url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "테스트 사용자")
        self.assertTemplateUsed(response, 'myapp/user_list.html')
    
    def test_user_detail_view(self):
        response = self.client.get(self.detail_url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "[email protected]")
        self.assertTemplateUsed(response, 'myapp/user_detail.html')

# 폼 테스트
class UserFormTest(TestCase):
    def test_valid_form(self):
        data = {'name': '새 사용자', 'email': '[email protected]', 'confirm_email': '[email protected]'}
        form = UserForm(data=data)
        self.assertTrue(form.is_valid())
    
    def test_invalid_email(self):
        # 이메일 불일치 테스트
        data = {'name': '새 사용자', 'email': '[email protected]', 'confirm_email': '[email protected]'}
        form = UserForm(data=data)
        self.assertFalse(form.is_valid())
        self.assertIn('confirm_email', form.errors)

# settings/production.py
from .base import *

DEBUG = False
ALLOWED_HOSTS = ['www.example.com', 'example.com']

# 데이터베이스 설정
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.environ.get('DB_NAME'),
        'USER': os.environ.get('DB_USER'),
        'PASSWORD': os.environ.get('DB_PASSWORD'),
        'HOST': os.environ.get('DB_HOST'),
        'PORT': os.environ.get('DB_PORT', '5432'),
    }
}

# 보안 설정
SECURE_HSTS_SECONDS = 31536000  # 1년
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_BROWSER_XSS_FILTER = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = 'DENY'

# 캐시 설정
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': f"redis://{os.environ.get('REDIS_HOST', 'localhost')}:6379/1",
    }
}

# 정적 파일 처리
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'

# 미디어 파일 처리
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
AWS_STORAGE_BUCKET_NAME = os.environ.get('AWS_STORAGE_BUCKET_NAME')
AWS_S3_REGION_NAME = os.environ.get('AWS_S3_REGION_NAME')
AWS_S3_CUSTOM_DOMAIN = f"{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com"