Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
from django.db import models
classProductQuerySet(models.QuerySet):
"""Product modeli için özel QuerySet."""defactive(self):
"""Sadece aktif ürünleri döndür."""returnself.filter(is_active=True)
defwith_category(self):
"""N+1 sorgularını önlemek için ilişkili kategoriyi seç."""returnself.select_related('category')
defwith_tags(self):
"""Many-to-many ilişkisi için tag'leri prefetch et."""returnself.prefetch_related('tags')
defin_stock(self):
"""Stok > 0 olan ürünleri döndür."""returnself.filter(stock__gt=0)
defsearch(self, query):
"""İsim veya açıklamaya göre ürünleri ara."""returnself.filter(
models.Q(name__icontains=query) |
models.Q(description__icontains=query)
)
classProduct(models.Model):
# ... alanlar ...
objects = ProductQuerySet.as_manager() # Özel QuerySet kullan# Kullanım
Product.objects.active().with_category().in_stock()
Manager Metodları
classProductManager(models.Manager):
"""Karmaşık sorgular için özel manager."""defget_or_none(self, **kwargs):
"""DoesNotExist yerine nesne veya None döndür."""try:
returnself.get(**kwargs)
exceptself.model.DoesNotExist:
returnNonedefcreate_with_tags(self, name, price, tag_names):
"""İlişkili tag'lerle ürün oluştur."""
product = self.create(name=name, price=price)
tags = [Tag.objects.get_or_create(name=name)[0] for name in tag_names]
product.tags.set(tags)
return product
defbulk_update_stock(self, product_ids, quantity):
"""Birden fazla ürün için toplu stok güncellemesi."""returnself.filter(id__in=product_ids).update(stock=quantity)
# Model'declassProduct(models.Model):
# ... alanlar ...
custom = ProductManager()
Django REST Framework Desenleri
Serializer Desenleri
from rest_framework import serializers
from django.contrib.auth.password_validation import validate_password
from .models import Product, User
classProductSerializer(serializers.ModelSerializer):
"""Product modeli için serializer."""
category_name = serializers.CharField(source='category.name', read_only=True)
average_rating = serializers.FloatField(read_only=True)
discount_price = serializers.SerializerMethodField()
classMeta:
model = Product
fields = [
'id', 'name', 'slug', 'description', 'price',
'discount_price', 'stock', 'category_name',
'average_rating', 'created_at'
]
read_only_fields = ['id', 'slug', 'created_at']
defget_discount_price(self, obj):
"""Uygulanabilirse indirimli fiyatı hesapla."""ifhasattr(obj, 'discount') and obj.discount:
return obj.price * (1 - obj.discount.percent / 100)
return obj.price
defvalidate_price(self, value):
"""Fiyatın negatif olmadığından emin ol."""if value < 0:
raise serializers.ValidationError("Price cannot be negative.")
return value
classProductCreateSerializer(serializers.ModelSerializer):
"""Ürün oluşturmak için serializer."""classMeta:
model = Product
fields = ['name', 'description', 'price', 'stock', 'category']
defvalidate(self, data):
"""Birden fazla alan için özel validation."""if data['price'] > 10000and data['stock'] > 100:
raise serializers.ValidationError(
"Cannot have high-value products with large stock."
)
return data
classUserRegistrationSerializer(serializers.ModelSerializer):
"""Kullanıcı kaydı için serializer."""
password = serializers.CharField(
write_only=True,
required=True,
validators=[validate_password],
style={'input_type': 'password'}
)
password_confirm = serializers.CharField(write_only=True, style={'input_type': 'password'})
classMeta:
model = User
fields = ['email', 'username', 'password', 'password_confirm']
defvalidate(self, data):
"""Şifrelerin eşleştiğini doğrula."""if data['password'] != data['password_confirm']:
raise serializers.ValidationError({
"password_confirm": "Password fields didn't match."
})
return data
defcreate(self, validated_data):
"""Hash'lenmiş şifre ile kullanıcı oluştur."""
validated_data.pop('password_confirm')
password = validated_data.pop('password')
user = User.objects.create(**validated_data)
user.set_password(password)
user.save()
return user
ViewSet Desenleri
from rest_framework import viewsets, status, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, IsAdminUser
from django_filters.rest_framework import DjangoFilterBackend
from .models import Product
from .serializers import ProductSerializer, ProductCreateSerializer
from .permissions import IsOwnerOrReadOnly
from .filters import ProductFilter
from .services import ProductService
classProductViewSet(viewsets.ModelViewSet):
"""Product modeli için ViewSet."""
queryset = Product.objects.select_related('category').prefetch_related('tags')
permission_classes = [IsAuthenticated, IsOwnerOrReadOnly]
filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
filterset_class = ProductFilter
search_fields = ['name', 'description']
ordering_fields = ['price', 'created_at', 'name']
ordering = ['-created_at']
defget_serializer_class(self):
"""Action'a göre uygun serializer döndür."""ifself.action == 'create':
return ProductCreateSerializer
return ProductSerializer
defperform_create(self, serializer):
"""Kullanıcı bağlamı ile kaydet."""
serializer.save(created_by=self.request.user)
@action(detail=False, methods=['get'])deffeatured(self, request):
"""Öne çıkan ürünleri döndür."""
featured = self.queryset.filter(is_featured=True)[:10]
serializer = self.get_serializer(featured, many=True)
return Response(serializer.data)
@action(detail=True, methods=['post'])defpurchase(self, request, pk=None):
"""Bir ürün satın al."""
product = self.get_object()
service = ProductService()
result = service.purchase(product, request.user)
return Response(result, status=status.HTTP_201_CREATED)
@action(detail=False, methods=['get'], permission_classes=[IsAuthenticated])defmy_products(self, request):
"""Mevcut kullanıcı tarafından oluşturulan ürünleri döndür."""
products = self.queryset.filter(created_by=request.user)
page = self.paginate_queryset(products)
serializer = self.get_serializer(page, many=True)
returnself.get_paginated_response(serializer.data)
Özel Action'lar
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
@api_view(['POST'])@permission_classes([IsAuthenticated])defadd_to_cart(request):
"""Kullanıcı sepetine ürün ekle."""
product_id = request.data.get('product_id')
quantity = request.data.get('quantity', 1)
try:
product = Product.objects.get(id=product_id)
except Product.DoesNotExist:
return Response(
{'error': 'Product not found'},
status=status.HTTP_404_NOT_FOUND
)
cart, _ = Cart.objects.get_or_create(user=request.user)
CartItem.objects.create(
cart=cart,
product=product,
quantity=quantity
)
return Response({'message': 'Added to cart'}, status=status.HTTP_201_CREATED)
Service Layer Deseni
# apps/orders/services.pyfrom typing importOptionalfrom django.db import transaction
from .models import Order, OrderItem
classOrderService:
"""Sipariş ilgili iş mantığı için service layer.""" @staticmethod @transaction.atomicdefcreate_order(user, cart: Cart) -> Order:
"""Sepetten sipariş oluştur."""
order = Order.objects.create(
user=user,
total_price=cart.total_price
)
for item in cart.items.all():
OrderItem.objects.create(
order=order,
product=item.product,
quantity=item.quantity,
price=item.product.price
)
# Sepeti temizle
cart.items.all().delete()
return order
@staticmethoddefprocess_payment(order: Order, payment_data: dict) -> bool:
"""Sipariş için ödemeyi işle."""# Ödeme gateway entegrasyonu
payment = PaymentGateway.charge(
amount=order.total_price,
token=payment_data['token']
)
if payment.success:
order.status = Order.Status.PAID
order.save()
# Onay email'i gönder
OrderService.send_confirmation_email(order)
returnTruereturnFalse @staticmethoddefsend_confirmation_email(order: Order):
"""Sipariş onay email'i gönder."""# Email gönderme mantığıpass
Caching Stratejileri
View Seviyesi Caching
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator
@method_decorator(cache_page(60 * 15), name='dispatch') # 15 dakikaclassProductListView(generic.ListView):
model = Product
template_name = 'products/list.html'
context_object_name = 'products'
# apps/users/signals.pyfrom django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth import get_user_model
from .models import Profile
User = get_user_model()
@receiver(post_save, sender=User)defcreate_user_profile(sender, instance, created, **kwargs):
"""Kullanıcı oluşturulduğunda profil oluştur."""if created:
Profile.objects.create(user=instance)
@receiver(post_save, sender=User)defsave_user_profile(sender, instance, **kwargs):
"""Kullanıcı kaydedildiğinde profili kaydet."""
instance.profile.save()
# apps/users/apps.pyfrom django.apps import AppConfig
classUsersConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'apps.users'defready(self):
"""Uygulama hazır olduğunda signal'leri import et."""import apps.users.signals
Middleware
Özel Middleware
# middleware/active_user_middleware.pyimport time
from django.utils.deprecation import MiddlewareMixin
classActiveUserMiddleware(MiddlewareMixin):
"""Aktif kullanıcıları takip etmek için middleware."""defprocess_request(self, request):
"""Gelen request'i işle."""if request.user.is_authenticated:
# Son aktif zamanı güncelle
request.user.last_active = timezone.now()
request.user.save(update_fields=['last_active'])
classRequestLoggingMiddleware(MiddlewareMixin):
"""Request'leri loglamak için middleware."""defprocess_request(self, request):
"""Request başlangıç zamanını logla."""
request.start_time = time.time()
defprocess_response(self, request, response):
"""Request süresini logla."""ifhasattr(request, 'start_time'):
duration = time.time() - request.start_time
logger.info(f'{request.method}{request.path} - {response.status_code} - {duration:.3f}s')
return response
Performans Optimizasyonu
N+1 Sorgu Önleme
# Kötü - N+1 sorguları
products = Product.objects.all()
for product in products:
print(product.category.name) # Her ürün için ayrı sorgu# İyi - select_related ile tek sorgu
products = Product.objects.select_related('category').all()
for product in products:
print(product.category.name)
# İyi - Many-to-many için prefetch
products = Product.objects.prefetch_related('tags').all()
for product in products:
for tag in product.tags.all():
print(tag.name)
# Toplu oluşturma
Product.objects.bulk_create([
Product(name=f'Product {i}', price=10.00)
for i inrange(1000)
])
# Toplu güncelleme
products = Product.objects.all()[:100]
for product in products:
product.is_active = True
Product.objects.bulk_update(products, ['is_active'])
# Toplu silme
Product.objects.filter(stock=0).delete()
Hızlı Referans
Desen
Açıklama
Split settings
Ayrı dev/prod/test ayarları
Özel QuerySet
Yeniden kullanılabilir sorgu metodları
Service Layer
İş mantığı ayrımı
ViewSet
REST API endpoint'leri
Serializer validation
Request/response dönüşümü
select_related
Foreign key optimizasyonu
prefetch_related
Many-to-many optimizasyonu
Cache first
Pahalı operasyonları cache'le
Signal'ler
Olay güdümlü aksiyonlar
Middleware
Request/response işleme
Unutmayın: Django birçok kısayol sağlar, ancak production uygulamaları için yapı ve organizasyon kısa koddan daha önemlidir. Bakımı kolay olacak şekilde oluşturun.
