Введение в Django: Создаём приложение портфолио

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

from pathlib import Path
from dotenv import load_dotenv
import os
 
load_dotenv()
 
SECRET_KEY = os.getenv('DJANGO_SECRET_KEY')
DEBUG = os.getenv('DEBUG', 'False') == 'True'

DJANGO_SECRET_KEY=your-secret-key-here
DEBUG=True

STATIC_URL = 'static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'
STATICFILES_DIRS = [
    BASE_DIR / 'static',
]

MEDIA_URL = 'media/'
MEDIA_ROOT = BASE_DIR / 'media'

from django.conf import settings
from django.conf.urls.static import static
 
urlpatterns = [
    # другие маршруты
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

ALLOWED_HOSTS = os.getenv('ALLOWED_HOSTS', '').split(',')

ALLOWED_HOSTS=localhost,127.0.0.1

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

if DEBUG:
    INSTALLED_APPS += ['debug_toolbar']
    MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']
    INTERNAL_IPS = ['127.0.0.1']

INSTALLED_APPS = [
    'pages.apps.PagesConfig',
    # остальные приложения
]

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        # остальные настройки
    }
]

from django.shortcuts import render
 
def home(request):
    return render(request, 'pages/home.html')

INSTALLED_APPS = [
    'pages.apps.PagesConfig',
    'projects.apps.ProjectsConfig',
    # остальные приложения
]

from django.db import models
 
class Project(models.Model):
    title = models.CharField('Название', max_length=100)
    description = models.TextField('Описание')
    technology = models.CharField('Технологии', max_length=50)
    image = models.ImageField('Изображение', upload_to='projects/')
    created_at = models.DateTimeField('Создано', auto_now_add=True)
    
    class Meta:
        verbose_name = 'Проект'
        verbose_name_plural = 'Проекты'
        ordering = ['-created_at']
    
    def __str__(self):
        return self.title

from django.urls import path
from . import views
 
urlpatterns = [
    path('', views.home, name='home'),
]

from django.urls import path
from . import views
 
urlpatterns = [
    path('', views.project_index, name='project_index'),
    path('<int:pk>/', views.project_detail, name='project_detail'),
]

from django.contrib import admin
from django.urls import path, include
 
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('pages.urls')),
    path('projects/', include('projects.urls')),
]

from django.contrib import admin
from .models import Project
 
@admin.register(Project)
class ProjectAdmin(admin.ModelAdmin):
    list_display = ['title', 'technology', 'created_at']
    list_filter = ['technology', 'created_at']
    search_fields = ['title', 'description']

from django.shortcuts import render, get_object_or_404
from .models import Project
 
def project_index(request):
    projects = Project.objects.all()
    context = {'projects': projects}
    return render(request, 'projects/project_index.html', context)
 
def project_detail(request, pk):
    project = get_object_or_404(Project, pk=pk)
    context = {'project': project}
    return render(request, 'projects/project_detail.html', context)

from django.utils.html import format_html
from django.contrib import admin
from .models import Project
 
@admin.register(Project)
class ProjectAdmin(admin.ModelAdmin):
    list_display = ['title', 'technology', 'created_at', 'image_preview']
    list_filter = ['technology', 'created_at']
    search_fields = ['title', 'description']
    readonly_fields = ['image_preview']
    
    def image_preview(self, obj):
        if obj.image:
            return format_html('<img src="{}" style="max-height: 50px;"/>', obj.image.url)
        return ''
    image_preview.short_description = 'Превью'

from django.core.exceptions import ValidationError
 
def validate_image(image):
    max_size = 2 * 1024 * 1024  # 2MB
    if image.size > max_size:
        raise ValidationError('Размер изображения не должен превышать 2MB')
 
class Project(models.Model):
    # ... остальные поля ...
    image = models.ImageField(
        'Изображение',
        upload_to='projects/',
        validators=[validate_image]
    )

from django.db import models
from PIL import Image
from io import BytesIO
from django.core.files.base import ContentFile
 
class Project(models.Model):
    # ... остальные поля ...
    
    def save(self, *args, **kwargs):
        if self.image:
            img = Image.open(self.image)
            if img.height > 1200 or img.width > 1200:
                output_size = (1200, 1200)
                img.thumbnail(output_size)
                output = BytesIO()
                img.save(output, format=img.format)
                output.seek(0)
                self.image = ContentFile(
                    output.read(),
                    name=self.image.name
                )
        super().save(*args, **kwargs)

from django.db import models
from django.utils.text import slugify
 
class Project(models.Model):
    title = models.CharField('Название', max_length=100)
    slug = models.SlugField('URL', unique=True, blank=True)
    description = models.TextField('Описание')
    technology = models.CharField('Технологии', max_length=50)
    image = models.ImageField('Изображение', upload_to='projects/')
    github_link = models.URLField('GitHub', blank=True)
    live_demo = models.URLField('Демо', blank=True)
    created_at = models.DateTimeField('Создано', auto_now_add=True)
    updated_at = models.DateTimeField('Обновлено', auto_now=True)
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        super().save(*args, **kwargs)

class Category(models.Model):
    name = models.CharField('Название', max_length=50)
    slug = models.SlugField('URL', unique=True)
    description = models.TextField('Описание', blank=True)
 
    class Meta:
        verbose_name = 'Категория'
        verbose_name_plural = 'Категории'
        ordering = ['name']
 
    def __str__(self):
        return self.name
 
class Project(models.Model):
    # ... существующие поля ...
    category = models.ForeignKey(
        Category,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        verbose_name='Категория'
    )

class Technology(models.Model):
    name = models.CharField('Название', max_length=30)
    icon = models.FileField('Иконка', upload_to='icons/', blank=True)
 
    class Meta:
        verbose_name = 'Технология'
        verbose_name_plural = 'Технологии'
        ordering = ['name']
 
    def __str__(self):
        return self.name
 
class Project(models.Model):
    # ... другие поля ...
    technologies = models.ManyToManyField(
        Technology,
        verbose_name='Технологии',
        related_name='projects'
    )

# Создание объекта
project = Project.objects.create(
    title='Мой проект',
    description='Описание проекта'
)
 
# Получение всех проектов
projects = Project.objects.all()
 
# Фильтрация
django_projects = Project.objects.filter(
    technologies__name='Django'
)
 
# Исключение
non_web_projects = Project.objects.exclude(
    category__name='Web'
)
 
# Сортировка
recent_projects = Project.objects.order_by('-created_at')
 
# Получение одного объекта
latest_project = Project.objects.latest('created_at')
 
# Агрегация
from django.db.models import Count
tech_count = Project.objects.annotate(
    tech_count=Count('technologies')
)

# Загрузка связанных объектов
projects = Project.objects.select_related('category').prefetch_related('technologies')
 
# Использование в представлении
def project_index(request):
    projects = Project.objects.select_related('category').prefetch_related('technologies')
    return render(request, 'projects/project_index.html', {'projects': projects})

class ProjectManager(models.Manager):
    def with_related(self):
        return self.select_related('category').prefetch_related('technologies')
    
    def published(self):
        return self.filter(is_published=True)
 
class Project(models.Model):
    # ... поля модели ...
    is_published = models.BooleanField('Опубликовано', default=True)
    objects = ProjectManager()

from django.core.exceptions import ValidationError
from django.utils import timezone
 
class Project(models.Model):
    # ... поля модели ...
    
    def clean(self):
        if self.live_demo and not self.live_demo.startswith('https://'):
            raise ValidationError({
                'live_demo': 'URL демо должен использовать HTTPS'
            })
    
    def validate_unique(self, *args, **kwargs):
        super().validate_unique(*args, **kwargs)
        if self.title:
            similar = Project.objects.filter(
                title__iexact=self.title
            ).exclude(pk=self.pk)
            if similar.exists():
                raise ValidationError({
                    'title': 'Проект с таким названием уже существует'
                })

from django.contrib import admin
from django.utils.html import format_html
 
@admin.register(Project)
class ProjectAdmin(admin.ModelAdmin):
    list_display = ['title', 'category', 'tech_list', 'created_at', 'is_published']
    list_filter = ['category', 'technologies', 'is_published']
    search_fields = ['title', 'description']
    prepopulated_fields = {'slug': ('title',)}
    filter_horizontal = ['technologies']
    
    def tech_list(self, obj):
        return ', '.join(t.name for t in obj.technologies.all())
    tech_list.short_description = 'Технологии'

from PIL import Image
from django.core.files.base import ContentFile
from io import BytesIO
 
class Project(models.Model):
    # ... поля модели ...
    
    def create_thumbnail(self):
        if not self.image:
            return
        
        img = Image.open(self.image)
        img.thumbnail((300, 300))
        
        thumb_io = BytesIO()
        img.save(thumb_io, format=img.format)
        
        thumbnail = ContentFile(thumb_io.getvalue())
        return thumbnail

from django.urls import reverse
 
class Project(models.Model):
    @property
    def technology_list(self):
        return list(self.technologies.values_list('name', flat=True))
    
    @property
    def absolute_url(self):
        return reverse('project_detail', kwargs={'pk': self.pk})

from django.db import models
 
class Project(models.Model):
    STATUS_DRAFT = 'draft'
    STATUS_PUBLISHED = 'published'
    STATUS_ARCHIVED = 'archived'
    
    STATUS_CHOICES = [
        (STATUS_DRAFT, 'Черновик'),
        (STATUS_PUBLISHED, 'Опубликовано'),
        (STATUS_ARCHIVED, 'В архиве'),
    ]
    
    status = models.CharField(
        'Статус',
        max_length=10,
        choices=STATUS_CHOICES,
        default=STATUS_DRAFT
    )
    
    def publish(self):
        if self.status == self.STATUS_DRAFT:
            self.status = self.STATUS_PUBLISHED
            self.save(update_fields=['status'])
    
    def archive(self):
        if self.status == self.STATUS_PUBLISHED:
            self.status = self.STATUS_ARCHIVED
            self.save(update_fields=['status'])

from django.db.models.signals import post_save
from django.dispatch import receiver
 
@receiver(post_save, sender=Project)
def project_post_save(sender, instance, created, **kwargs):
    if created:
        # Отправка уведомления о новом проекте
        notify_about_new_project(instance)
    else:
        # Обновление кэша
        cache.delete(f'project_{instance.pk}')

class Tag(models.Model):
    name = models.CharField('Название', max_length=50)
    slug = models.SlugField('URL', unique=True)
    
    def __str__(self):
        return self.name
    
    class Meta:
        verbose_name = 'Тег'
        verbose_name_plural = 'Теги'
 
class Project(models.Model):
    tags = models.ManyToManyField(Tag, blank=True, verbose_name='Теги')
    
    def add_tags(self, tag_names):
        for name in tag_names:
            tag, created = Tag.objects.get_or_create(
                name=name,
                slug=slugify(name)
            )
            self.tags.add(tag)

from django.contrib.postgres.search import SearchVector, SearchQuery, SearchRank
 
class ProjectManager(models.Manager):
    def search(self, query):
        search_vector = SearchVector('title', weight='A') + \
                       SearchVector('description', weight='B')
        search_query = SearchQuery(query)
        
        return self.annotate(
            rank=SearchRank(search_vector, search_query)
        ).filter(rank__gte=0.3).order_by('-rank')

class ProjectHistory(models.Model):
    project = models.ForeignKey(
        Project,
        on_delete=models.CASCADE,
        related_name='history'
    )
    title = models.CharField('Название', max_length=100)
    description = models.TextField('Описание')
    changed_at = models.DateTimeField('Изменено', auto_now_add=True)
    changed_by = models.ForeignKey(
        'auth.User',
        on_delete=models.SET_NULL,
        null=True
    )
    
    class Meta:
        ordering = ['-changed_at']
        verbose_name = 'История изменений'
        verbose_name_plural = 'История изменений'

@receiver(post_save, sender=Project)
def save_project_history(sender, instance, **kwargs):
    ProjectHistory.objects.create(
        project=instance,
        title=instance.title,
        description=instance.description,
        changed_by=instance._current_user if hasattr(instance, '_current_user') else None
    )

class Comment(models.Model):
    project = models.ForeignKey(
        Project,
        on_delete=models.CASCADE,
        related_name='comments'
    )
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    text = models.TextField('Текст')
    created_at = models.DateTimeField('Создано', auto_now_add=True)
    
    class Meta:
        ordering = ['-created_at']
        verbose_name = 'Комментарий'
        verbose_name_plural = 'Комментарии'
 
class Project(models.Model):
    def add_comment(self, user, text):
        return self.comments.create(author=user, text=text)
    
    def recent_comments(self):
        return self.comments.select_related('author')[:5]

class ProjectQuerySet(models.QuerySet):
    def with_comments_count(self):
        return self.annotate(
            comments_count=models.Count('comments')
        )
    
    def popular(self):
        return self.with_comments_count().order_by('-comments_count')
    
    def by_technology(self, technology_name):
        return self.filter(technologies__name=technology_name)
 
class Project(models.Model):
    objects = ProjectQuerySet.as_manager()

def project_image_path(instance, filename):
    return f'projects/{instance.slug}/{filename}'
 
class ProjectImage(models.Model):
    project = models.ForeignKey(
        Project,
        on_delete=models.CASCADE,
        related_name='images'
    )
    image = models.ImageField(
        'Изображение',
        upload_to=project_image_path
    )
    caption = models.CharField('Подпись', max_length=200, blank=True)
    order = models.PositiveIntegerField('Порядок', default=0)
    
    class Meta:
        ordering = ['order']
        verbose_name = 'Изображение'
        verbose_name_plural = 'Изображения'

from django.views.generic import ListView
from .models import Project
 
class ProjectListView(ListView):
    model = Project
    template_name = 'projects/project_list.html'
    context_object_name = 'projects'
    paginate_by = 9
    
    def get_queryset(self):
        queryset = super().get_queryset()
        return queryset.select_related('category').prefetch_related('technologies')

from django.views.generic import DetailView
 
class ProjectDetailView(DetailView):
    model = Project
    template_name = 'projects/project_detail.html'
    
    def get_context_data(self, [B]kwargs):
        context = super().get_context_data([/B]kwargs)
        context['related_projects'] = Project.objects.filter(
            category=self.object.category
        ).exclude(pk=self.object.pk)[:3]
        return context

from django.views.generic import ListView
from django.shortcuts import get_object_or_404
from .models import Category
 
class CategoryProjectsView(ListView):
    template_name = 'projects/category_projects.html'
    context_object_name = 'projects'
    paginate_by = 9
    
    def get_queryset(self):
        self.category = get_object_or_404(Category, slug=self.kwargs['slug'])
        return Project.objects.filter(category=self.category)
    
    def get_context_data(self, [B]kwargs):
        context = super().get_context_data([/B]kwargs)
        context['category'] = self.category
        return context

from django.views.generic import FormView
from .forms import ProjectSearchForm
 
class ProjectSearchView(FormView):
    template_name = 'projects/search.html'
    form_class = ProjectSearchForm
    
    def form_valid(self, form):
        query = form.cleaned_data['query']
        self.results = Project.objects.search(query)
        return self.render_to_response(self.get_context_data(form=form))
    
    def get_context_data(self, [B]kwargs):
        context = super().get_context_data([/B]kwargs)
        if hasattr(self, 'results'):
            context['results'] = self.results
        return context

from django.contrib import messages
from django.urls import reverse_lazy
 
class ProjectFormMixin:
    def form_valid(self, form):
        messages.success(self.request, 'Проект успешно сохранен')
        return super().form_valid(form)
    
    def form_invalid(self, form):
        messages.error(self.request, 'Пожалуйста, исправьте ошибки в форме')
        return super().form_invalid(form)
 
class ProjectCreateView(ProjectFormMixin, CreateView):
    model = Project
    template_name = 'projects/project_form.html'
    success_url = reverse_lazy('project_list')
    fields = ['title', 'description', 'category', 'technologies', 'image']
 
class ProjectUpdateView(ProjectFormMixin, UpdateView):
    model = Project
    template_name = 'projects/project_form.html'
    fields = ['title', 'description', 'category', 'technologies', 'image']
    
    def get_success_url(self):
        return self.object.get_absolute_url()

from django.core.cache import cache
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
 
@method_decorator(cache_page(60 * 15), name='dispatch')
class CachedProjectListView(ProjectListView):
    def get_context_data(self, [B]kwargs):
        context = super().get_context_data([/B]kwargs)
        context['categories'] = cache.get_or_set(
            'all_categories',
            Category.objects.all(),
            60 * 60
        )
        return context

from django.http import JsonResponse
 
def load_more_projects(request):
    page = request.GET.get('page', 1)
    projects = Project.objects.all()[(page-1)*6:page*6]
    
    data = [{
        'title': project.title,
        'description': project.description[:100],
        'image_url': project.image.url if project.image else None,
        'url': project.get_absolute_url()
    } for project in projects]
    
    return JsonResponse({
        'projects': data,
        'has_more': Project.objects.count() > page * 6
    })

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-snowflake',
    }
}

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
    }
}

STATIC_ROOT = BASE_DIR / 'staticfiles'
STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'

MIDDLEWARE = [
    'django.middleware.gzip.GZipMiddleware',
    # другие middleware
]

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

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'ERROR',
            'class': 'logging.FileHandler',
            'filename': BASE_DIR / 'error.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'ERROR',
            'propagate': True,
        },
    },
}

# gunicorn_config.py
bind = "127.0.0.1:8000"
workers = 3
accesslog = "access.log"
errorlog = "error.log"

SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True

if DEBUG:
    MIDDLEWARE += ['silk.middleware.SilkyMiddleware']
    INSTALLED_APPS += ['silk']

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'portfolio',
        'BACKUP': {
            'DIRECTORY': BASE_DIR / 'backups',
            'DAYS': 7,
        }
    }
}

class ProjectService:
    def create_project(self, data):
        project = Project(**data)
        project.full_clean()
        project.save()
        self._process_images(project, data.get('images', []))
        return project
 
    def _process_images(self, project, images):
        for image in images:
            ProjectImage.objects.create(
                project=project,
                image=image
            )

class ProjectDomain:
    def __init__(self, project):
        self.project = project
 
    def publish(self):
        if not self.project.is_ready_for_publication():
            raise ValidationError("Project is not ready")
        self.project.status = Project.STATUS_PUBLISHED
        self.project.published_at = timezone.now()
        self.project.save()

import sentry_sdk
from sentry_sdk.integrations.django import DjangoIntegration
 
sentry_sdk.init(
    dsn="your-dsn-here",
    integrations=[DjangoIntegration()],
    traces_sample_rate=1.0,
)

from ddtrace import patch_all
patch_all()
 
DATADOG_TRACE = {
    'DEFAULT_SERVICE': 'portfolio',
    'TAGS': {'env': 'production'},
}