# django

***

**1. CRUD Operations with Django Models**

```python
# Create a new model instance
product = Product(name="Apple", price=10.0)
product.save()

# Retrieve a model instance
product = Product.objects.get(id=1)

# Update a model instance
product.price = 12.0
product.save()

# Delete a model instance
product.delete()
```

**2. Querying Objects with Django ORM**

```python
# Get all products with price greater than 10
products = Product.objects.filter(price__gt=10.0)

# Get the first product with name "Apple"
product = Product.objects.get(name="Apple")

# Order products by price in descending order
products = Product.objects.order_by('-price')
```

**3. Creating Django Forms**

```python
class ProductForm(forms.ModelForm):
    class Meta:
        model = Product
        fields = ['name', 'price']
```

**4. Handling User Authentication with Django**

```python
from django.contrib.auth.models import User

# Create a new user
user = User.objects.create_user('username', 'email@example.com', 'password')

# Authenticate a user
user = authenticate(username='username', password='password')
```

**5. Django Model Inheritance**

```python
class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=6, decimal_places=2)

class Book(Product):
    author = models.CharField(max_length=100)
```

**6. Django Middleware**

```python
class MyMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Do something before the view is called
        response = self.get_response(request)
        # Do something after the view is called
        return response
```

**7. Django Template Filters**

```python
from django import template

register = template.Library()

@register.filter
def currency(value):
    return f"${value:.2f}"
```

**8. Django Custom Manager**

```python
from django.db import models

class MyManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(is_active=True)
```

**9. Django REST Framework**

```python
from rest_framework import serializers, viewsets, routers

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = ['id', 'name', 'price']

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

router = routers.DefaultRouter()
router.register('products', ProductViewSet)
```

**10. Django Channels**

```python
import channels

@channels.routing.route("websocket.connect")
def connect(message):
    message.reply_channel.send({"accept": True})

@channels.routing.route("websocket.receive")
def receive(message):
    print(message.text)

@channels.routing.route("websocket.disconnect")
def disconnect(message):
    pass
```

**11. Django Internationalization (i18n)**

```python
from django.utils.translation import gettext as _

# Define translation in settings.py
LANGUAGE_CODE = 'en-us'

# Translate in template
<h1>{_('Welcome to Django')}</h1>
```

**12. Django Password Reset**

```python
from django.contrib.auth.forms import PasswordResetForm

# Reset password form
form = PasswordResetForm(data={'email': 'email@example.com'})
if form.is_valid():
    form.save()
```

**13. Django Admin**

```python
from django.contrib import admin

# Register model in admin interface
admin.site.register(Product)
```

**14. Django Mail**

```python
from django.core.mail import send_mail

send_mail(
    'Subject',
    'Message',
    'from@example.com',
    ['to@example.com'],
    fail_silently=False
)
```

**15. Django Caching**

```python
from django.core.cache import cache

# Set cache value
cache.set('foo', 'bar')

# Retrieve cache value
value = cache.get('foo')
```

**16. Django File Uploads**

```python
from django.core.files.storage import FileSystemStorage

# File storage
fs = FileSystemStorage()
fs.save('my_file.txt', File(open('myfile.txt', 'rb')))
```

**17. Django Signal Processing**

```python
from django.db.models.signals import post_save

# Signal handler
def my_handler(sender, **kwargs):
    # Do something when a model is saved
    pass

# Connect signal handler
post_save.connect(my_handler, sender=Product)
```

**18. Django Haystack Search**

```python
from haystack import indexes

class ProductIndex(indexes.SearchIndex, indexes.Indexable):
    text = indexes.CharField(document=True, use_template=True)

# Rebuild search index
ProductIndex().reindex()
```

**19. Django Cart**

```python
from django.contrib.sessions.models import Session

# Retrieve cart from session
session = Session.objects.get(session_key='...')
cart = session.get('cart', {})
```

**20. Django Celery Task Scheduling**

```python
from celery import task

@task
def my_task():
    # Perform task asynchronously
    pass
```

**21. Django HTML Purifier**

```python
from django.contrib.admin import SimpleListFilter

class MyFilter(SimpleListFilter):
    title = 'Title'
    parameter_name = 'title'

    def lookups(self, request, model_admin):
        # Define filter options
        return [('option1', 'Option 1'), ('option2', 'Option 2')]

    def queryset(self, request, queryset):
        # Filter queryset based on selected option
        if self.value() == 'option1':
            return queryset.filter(...)
        elif self.value() == 'option2':
            return queryset.filter(...)
        else:
            return queryset
```

**22. Django Google Auth**

```python
from django.contrib.auth.backends import ModelBackend

class GoogleAuthBackend(ModelBackend):
    def authenticate(self, request, **kwargs):
        # Authenticate user using Google OAuth token
        pass
```

**23. Django Stripe Payment**

```python
import stripe

# Create a Stripe charge
stripe.Charge.create(
    amount=1000,
    currency="usd",
    source="tok_...
)
```

**24. Django PayPal Payment**

```python
from paypal.standard.models import ST_PP_COMPLETED

# PayPal payment processing
if request.method == 'POST' and request.POST.get('txn_type') == 'web_accept':
    order = Order.objects.get(id=request.POST.get('custom'))
    if request.POST.get('payment_status') == ST_PP_COMPLETED:
        """
        Payment processing logic
        """
```

**25. Django REST Framework JWT Authentication**

```python
from rest_framework_jwt.authentication import JSONWebTokenAuthentication

# JWT authentication
authentication_classes = [JSONWebTokenAuthentication]
```

**26. Django User Permissions**

```python
from django.contrib.auth.models import Permission

# Create a new permission
permission = Permission.objects.create(codename='can_edit_product', name='Can edit product')

# Assign permission to a user
user.user_permissions.add(permission)
```

**27. Django Group Permissions**

```python
from django.contrib.auth.models import Group

# Create a new group
group = Group.objects.create(name='Editors')

# Assign permission to a group
group.permissions.add(permission)

# Add user to group
user.groups.add(group)
```

**28. Django Crispy Forms**

```python
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Submit

# Crispy form helper
helper = FormHelper()
helper.add_input(Submit('submit', 'Save'))
```

**29. Django Extensions**

```python
from django_extensions.management.commands.runserver_plus import Command as RunserverPlusCommand

# Run Django development server with debug toolbar
python manage.py runserver_plus
```

**30. Django debug\_toolbar**

```python
# Install debug_toolbar
pip install django-debug-toolbar

# Add debug toolbar to INSTALLED_APPS
INSTALLED_APPS = [
    ...
    'debug_toolbar',
]

# Add debug toolbar middleware
MIDDLEWARE = [
    ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
]

# Enable debug toolbar in settings.py
DEBUG_TOOLBAR_CONFIG = {
    'INTERCEPT_REDIRECTS': False,
}
```

**31. Django htmx**

```python
pip install django-htmx

# Add htmx to INSTALLED_APPS
INSTALLED_APPS = [
    ...
    'htmx.apps.HtmxConfig',
]
```

**32. Django livewire**

```python
pip install django-livewire

# Add livewire to INSTALLED_APPS
INSTALLED_APPS = [
    ...
    'livewire',
]

# Configure livewire
LIVEWIRE_CONFIG = {
    'dom_id_prefix': 'lw',
}
```

**33. Django query count**

```python
from django.db import connection

# Display number of queries executed
print(len(connection.queries))
```

**34. Django benchmark**

```python
from django.core.cache import CacheKeyWarning
from django.db.models.query import QuerySet

# Display benchmark results for a queryset
qs = QuerySet().all()
with CacheKeyWarning(warnings.catch_warnings()):
    warnings.simplefilter('ignore')
    results = qs.explain(analyze=True)

# Print benchmark results
for row in results:
    print(row)
```

**35. Django inspectdb**

```python
python manage.py inspectdb > models.py
```

**36. Django loaddata**

```python
python manage.py loaddata initial_data.json
```

**37. Django dumpdata**

```python
python manage.py dumpdata > data.json
```

**38. Django migrate**

```python
python manage.py migrate
```

**39. Django runserver**

```python
python manage.py runserver
```

**40. Django shell**

```python
python manage.py shell
```

**41. Django createsuperuser**

```python
python manage.py createsuperuser
```

**42. Django startapp**

```python
python manage.py startapp myapp
```

**43. Django startapp**

```python
python manage.py startapp myapp
```

**44. Django startproject**

```python
python manage.py startproject myproject
```

**45. Django collectstatic**

```python
python manage.py collectstatic
```

**46. Django test**

```python
python manage.py test
```

**47. Django coverage**

```python
python manage.py coverage
```

**48. Django freezegun**

```python
from freezegun import freeze_time

@freeze_time("2023-01-01")
def my_test():
    pass
```

**49. Django pytest**

```python
import pytest

@pytest.mark.django_db
def test_my_model():
    pass
```

**50. Django factory\_boy**

```python
from factory import Faker, SubFactory
from factory.django import DjangoModelFactory

class UserFactory(DjangoModelFactory):
    class Meta:
        model = User
    username = Faker('user_name')
    email = Faker('email')
```

**51. Django model\_mommy**