├── library
│   ├── __init__.py
│   ├── forms.py
│   ├── models.py
│   ├── views.py
│   ├── tests
│   │   ├── __init__.py
│   │   ├── test_forms.py
│   │   ├── test_models.py
│   │   └── test_views.py

# models.py

class Author(models.Model):
    firstname = models.CharField(max_length=100, null=True, blank=True)
    lastname = models.CharField(max_length=100)

    def __str__(self):
        return u'%s %s' % (self.firstname, self.lastname)

# tests/test_models.py
from django.test import TestCase
from library.models import Author


class AuthorAsStringTest(TestCase):

    def test_with_first_name(self):

        author = Author.objects.create(firstname='René',
                                       lastname='Descartes')
        self.assertEqual(str(author), 'René Descartes')

    def test_without_first_name(self):

        author = Author.objects.create(lastname='Platon')
        self.assertEqual(str(author), 'Platon')

$ ./manage.py test library
Creating test database for alias 'default'...
.F
======================================================================
FAIL: test_without_first_name (library.tests.test_models.AuthorAsStringTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/al/makina-slides/django/example_projects/libraryproject/library/tests/test_models.py", line 16, in test_without_first_name
    self.assertEqual(str(author), 'Platon')
AssertionError: 'None Platon' != 'Platon'
- None Platon
+ Platon

----------------------------------------------------------------------
Ran 2 tests in 0.002s

FAILED (failures=1)
Destroying test database for alias 'default'...

class Author(models.Model):
    firstname = models.CharField(max_length=100, null=True, blank=True)
    lastname = models.CharField(max_length=100)

    def __str__(self):
        if self.firstname:
            return u'%s %s' % (self.firstname, self.lastname)
        else:
            return self.lastname

$ ./manage.py test library.tests.test_models
Creating test database for alias 'default'...
..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK
Destroying test database for alias 'default'...

from datetime import date
from django.test import TestCase
from library.models import Book


class BookViewTest(TestCase):

    def test_recent_books_view(self):
        recent_date = date.today()
        recent_book = Book.objects.create(title='Titre du livre récent',
                                          published=recent_date)

        old_date = recent_date.replace(year=recent_date.year - 1)
        old_book = Book.objects.create(title='Titre du vieux livre',
                                       published=old_date)

        response = self.client.get("/library/recent/")

        self.assertNotContains(response, old_book.title)
        self.assertContains(response, recent_book.title)

class Book(models.Model):
    title = models.CharField(max_length=200)
    published = models.DateField(null=True, blank=True)

from django.shortcuts import render
from datetime import date
from .models import Book


def recent_books(request):
    today = date.today()
    threshold = today.replace(year=today.year - 1)

    results = Book.objects.filter(published__gt=threshold)

    return render(request, 'library/book_list.html', {
        'results': results
    })

# forms.py
from django import forms

class PeriodForm(forms.Form):
    begin = forms.DateField()
    end = forms.DateField()

    def __init__(self, *args, **kwargs):
        super(PeriodForm, self).__init__(*args, **kwargs)

        begin = self.initial.get('begin', None)
        if begin:
            self.initial['end'] = begin.replace(month=begin.month + 1)

# tests/test_forms.py
from datetime import date
from django.test import TestCase
from library.forms import PeriodForm


class PeriodFormTest(TestCase):

    def test_init_without_begin(self):
        f = PeriodForm()
        self.assertIsNone(f.initial.get('end'))

    def test_init_with_begin(self):
        initial = {'begin': date(2014, 1, 1)}
        f = PeriodForm(initial=initial)
        self.assertEqual(f.initial.get('begin'), date(2014, 1, 1))
        self.assertEqual(f.initial.get('end'), date(2014, 2, 1))

$ coverage run --branch --source=library ./manage.py test
$ coverage report
Name                                 Stmts   Miss Branch BrPart  Cover
----------------------------------------------------------------------
library/__init__.py                      0      0      0      0   100%
library/admin.py                         1      0      0      0   100%
library/apps.py                          3      0      0      0   100%
library/forms.py                         9      0      2      0   100%
library/migrations/0001_initial.py       6      0      0      0   100%
library/migrations/__init__.py           0      0      0      0   100%
library/models.py                       11      0      2      0   100%
library/tests/__init__.py                0      0      0      0   100%
library/tests/test_forms.py             12      0      0      0   100%
library/tests/test_models.py             9      0      0      0   100%
library/tests/test_views.py             12      0      0      0   100%
library/urls.py                          3      0      0      0   100%
library/views.py                         8      0      0      0   100%
----------------------------------------------------------------------
TOTAL                                   74      0      4      0   100%

>>> Book.objects.filter(title__icontains='django') \
                .exclude(relase__lte=date('2014-01-01')) \
                .order_by('price')

>>> Book.objects.filter(name__icontains='django') \
                .values('title' , 'release')

[{'title': 'Two scoops of django', 'release': date(2013, 08, 31)}, ]

>>> Book.objects.filter(name__icontains='django') \
                .values_list('title' , 'release')

[('Two scoops of django', date(2013, 08, 31)),
 ('Django avancé', date(2013, 05, 15))]

>>> Book.objects.filter(name__icontains='django') \
                .values_list('title', flat=True)

['Two scoops of django', 'Django avancé']

book = Book.objects.create(title="New django book", price="42€")

book, created = Book.objects.get_or_create(
    title="New django book", date(2013, 05, 15),
    defaults={'price': '42€'})

from django.db import models

class Book(models.Model):
    #...
    objects = models.Manager()

>>> Book.objects.get(pk=12)
>>> Book.objects.all()
>>> Book.objects.filter(title__icontains='django')
>>> Book.objects.exclude(date__lt=date(2013, 01, 01))

from django.db import models

class CustomBookManager(models.Manager):
    # ...

class Book(models.Model):
    #...
    custom_books = CustomBookManager()

from django.db import models

class AuthorManager(models.Manager):
    def with_nb_books(self):
        self.get_query_set() \
            .annotate(nb_books=Count('books')) \
            .order_by('nb_books')

class Author(models.Model):
    #...
    objects = AuthorManager()

>>> authors_with_nb_books = Author.objects.with_nb_books()
>>> authors_with_nb_books[0]
<Author : John Doe>
>>> authors_with_nb_books[0].nb_books
42

from django.db import models

class EnglishBookManager(models.Manager):
    def get_query_set(self):
         return Manager.get_queryset(self).filter(lang='EN')

class FrenchBookManager(models.Manager):
    def get_query_set(self):
         return Manager.get_queryset(self).filter(lang='FR')

class Book(models.Model):
    #...
    objects = models.Manager()
    english_books = EnglishBookManager()
    french_books = FrenchBookManager()

# models.py

class CommonInfo(models.Model):
    creation_date = models.DateField()
    modification_date = models.DateField()

    class Meta:
        abstract = True

class Book(CommonInfo):
    title = models.CharField(max_length=100)
    # ...

class Author(CommonInfo):
    name = models.CharField(max_length=100)
    # ...

# models.py

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author)

class Comic(Book):
    illustrator = models.CharField(max_length=100)
    # ...

class Biography(Book):
    personage = models.CharField(max_length=100)
    # ...

# models.py

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author)

class OrderedByAuthorBook(Book):

    class Meta:
        proxy = True
        ordering = ['author']

 {% for task in object_list %}
 <li>
   <a href="{% url 'task_detail' task.pk %}">{{ task }}</a>
   Liste: {{task.todo_list.label }}
 </li>
 {% endfor %}

class TaskList(ListView):
    model = Task

    def get_queryset(self):
        queryset = super(TaskList, self).get_queryset()
        return queryset.select_related("todo_list")

{% for list in object_list %}
  <li>
    <a href="{% url 'todolist_detail' list.pk %}">{{ list }}</a>
    Users: {% for user in list.users.all %}
              {{ user.username }}
           {% endfor %}
  </li>
{% endfor %}

class TodoListList(ListView):
    model = TodoList

    def get_queryset(self):
        queryset = super(TodoListList, self).get_queryset()
        return queryset.prefetch_related("users")

from django.db.models.signals import post_save
from django.dispatch import receiver
from todo.models import Task

@receiver(post_save, sender=Task)
def db_update_callback(sender, instance, created, **kwargs):
    print('Task "{0}" saved!'.format(instance.name))

# some_app/views.py
from django.views.generic import TemplateView

class AboutView(TemplateView):
    template_name = "about.html"

from django.http import HttpResponse

def my_view(request):
    if request.method == 'GET':
        # traitements
        return HttpResponse('result')

from django.http import HttpResponse
from django.views.generic.base import View

class MyView(View):
    def get(self, request):
        # traitements
        return HttpResponse('result')

from django.contrib.auth.decorators import login_required

@login_required()
def my_view(request):
    # Seul un utilisateur connecté peut accéder à cette vue
    # ...

from django.contrib.auth.decorators import login_required

@require_http_methods(["GET", "POST"])
def my_view(request):
    # On ne peut pas accéder à cette vue qu'en GET ou POST
    # ...

# views.py
from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator

class MyProtectedView(TemplateView):
    template_name = 'my_protected_view.html'

    @method_decorator(login_required)
    def dispatch(self, *args, **kwargs):
        return super(MyProtectedView, self).dispatch(*args, **kwargs)

# urls.py
from django.contrib.auth.decorators import login_required
from my_app.views import MyProtectedView

urlpatterns = patterns('',
    (r'^secret/', login_required(MyProtectedView.as_view())),
)

from django.http import Http404

def book_detail(request, book_id):

    try:
        book = Book.objects.get(pk=book_id)
    except Book.DoesNotExist:
        raise Http404

    return render(request, 'library/book_detail.html', {
        'book': book
    })

from django.core.exceptions import PermissionDenied

def book_detail(request, book_id):

    if not library.is_registered(user):
        raise PermissionDenied

    book = Book.objects.get(pk=book_id)

    return render(request, 'books/detail.html', {'book': book})

# views.py
def my_403_view(request):
    send_mail_to_admin()
    # ...
    return render(request, '403.html')

# urls.py
urlpatterns = patterns('',
    # ...
)
handler403 = 'my_app.views.my_403_view'

class SimpleMiddleware(object):
    def __init__(self, get_response):
        # Initialisation
        self.get_response = get_response

    def __call__(self, request):

        # Code exécuté pour chaque requête avant la vue

        response = self.get_response(request)

        # Code exécuté pour chaque requête après la vue

        return response

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',
]

├── my_app
│   ├── __init__.py
│   ├── admin.py
│   ├── forms.py
│   ├── models.py
│   ├── templatetags
│   │   ├── __init__.py
│   │   └── my_todo_app_filters.py

{{ variable|my_simple_filter }}

{{ variable|my_filter:"foo" }}

# filters.py
def lower(value):
    """Converts a string into all lowercase"""
    return value.lower()

{# template #}
{{ variable|lower }}

# filters.py
def cut(value, arg):
    """Removes all values of arg from the given string"""
    return value.replace(arg, '')

{# template #}
{{ variable|cut:'0' }}

from django import template
register = template.Library()

def my_filter(value):
    # code du filtre

register.filter('my_filter', my_filter)

from django import template
register = template.Library()

@register.filter()
def my_filter(value):
    # code du filtre

@register.filter(is_safe=True)
def my_filter(value):
    # code du filtre

from django.utils.safestring import mark_safe

@register.filter(is_safe=True)
def my_filter(value):
    # code du filtre
    return mark_safe(output)

# forms.py
class AccountForm(forms.Form):
    lastname = forms.CharField(max_length=100)
    firstname = forms.CharField(max_length=100)

#views.py
def create_account(request):
    initial = {
        'lastname': request.user.last_name,
        'firstname': request.user.first_name
    }
    form = AccountForm(initial=initial)

# forms.py
class PeriodForm(forms.Form):
    begin = forms.DateField()
    end = forms.DateField()

    def __init__(self, *args, **kwargs):
        super(PeriodForm, self).__init__(*args, **kwargs)

        begin = self.initial.get('begin', None)
        if begin:
            self.initial['end'] = begin + delta(months=1)

# forms.py
class SearchBookForm(forms.Form):
    search_text = forms.CharField(max_length=100)

    def clean_search_text(self):
        search_text = self.cleaned_data['search_text']
        if 'django' not in search_text:
            msg = 'You should search Django books :)!'
            raise forms.ValidationError(msg)
        return search_text

# forms.py
class PeriodForm(forms.Form):
    begin = forms.DateField()
    end = forms.DateField()

    def clean(self):
        cleaned_data = super(PeriodForm, self).clean()
        begin = cleaned_data.get('begin')
        end = cleaned_data.get('end')

        if begin and end and begin >= end:
            msg = 'End date must be later than begin date!'
            self._errors.setdefault('end', []).append(msg)

        return cleaned_data

# settings.py
INSTALLED_APPS = (
  ...
  'django.contrib.staticfiles',
  ...
)

STATIC_URL = '/static/'

$ ./manage.py collecstatic

{# my_app/templates/my_app/my_template.html #}
{% load static %}
...
<img src="{% static "my_app/img/myexample.jpg" %}" alt="My image"/>

{# base.html #}
{% load static %}
<html>
  <head>
    <link href="{% static "my_app/css/styles.css" %}" />

# models.py

class Book(models.Model):
    # ...
    summary = models.FileField(upload_to='summaries')

class Author(models.Model):
    # ...
    photo = models.ImageField(upload_to='avatars')

>>> book = Book.objects.get(pk=12)
>>> book.summary
<FieldFile: summaries/summary_12.pdf>
>>> book.summary.url
u'http://my_site.com/media/summaries/summary_12.pdf'

# forms.py
class MyForm(forms.Form):
    # ...
    my_file = forms.FileField()

# views.py
def my_view(request):
    # ...
    form = MyForm(request.POST, request.FILES)
    # ...

{# my_app/templates/my_app/my_form_template.html #}
<form action="" enctype="multipart/form-data" method="POST">
 ...
</form>

from django.utils.translation import ugettext_lazy as _

# models.py
from django.utils.translation import ugettext_lazy as _

class Book(models.Model):
    name = models.CharField(max_length=100,
                            verbose_name=_('Title'))

    class Meta:
        db_table = 'task'
        verbose_name = _('Book')
        verbose_name_plural = _('Books')

# forms.py
from django.utils.translation import ugettext_lazy as _

class BookSearchForm(models.Model):
    search_text = models.CharField(label=_('Search text'))

# views.py
from django.utils.translation import ugettext_lazy as _

def confirmation(request, result):
    if result == 'OK':
        confirmation = _('Verification succeeded')
    else:
        confirmation = _('Verification failed')
    # Render form
    return render(request, 'confirmation.html', {
        'confirmation': confirmation,
    })

{% load i18n %}
<title>{% trans "List of books" %}</title>
<title>{% trans page_title %}</title>

{% load i18n %}
{% blocktrans with book_t=book|title author_t=author|title %}
<p>This is {{ book_t }} by {{ author_t }}</p>
{% endblocktrans %}

 $ django-admin.py makemessages -l fr

 $ django-admin.py compilemessages -l fr

$ ./manage.py

[django]
    check
    cleanup
    compilemessages
    createcachetable
    ...

├── my_app
│   ├── __init__.py
│   ├── admin.py
│   ├── models.py
│   ├── management
│   │   ├── __init__.py
│   │   ├── commands
│   │   │   ├── __init__.py
│   │   │   ├── my_test_command.py

# my_app/management/command/my_test_command.py
from django.core.management.base import BaseCommand, CommandError


class Command(BaseCommand):
    args = '...'
    help = 'Do specific administration stuff'


    def handle(self, *args, **options):

        self.stdout.write('Command started')
        # Traitements
        self.stdout.write('Command ended')

$ ./manage.py my_test_command

# Cron tasks
0 * * * * /project_path/manage.py my_test_command

from django.core import management
management.call_command("my_test_command")

# admin.py
from django.contrib import admin
from myproject.myapp.models import Book

admin.site.register(Book)

# admin.py
from django.contrib import admin
from myproject.myapp.models import Book

class BookAdmin(admin.ModelAdmin):
    # Personnalisations

admin.site.register(Book, BookAdmin)

# admin.py
from django.contrib import admin
from myproject.myapp.models import Book

class BookAdmin(admin.ModelAdmin):
    list_display = ['title', 'release']
    list_display_links = ['title']
    list_filter = ['author']
    date_hierarchy = 'release'
    search_fields = ['title', 'author__name']

admin.site.register(Book, BookAdmin)

# admin.py
from django.contrib import admin
from django import forms
from myproject.myapp.models import Book

class BookAdminForm(forms.ModelForm):
    # ...

class BookAdmin(admin.ModelAdmin):
    list_display = ['title', 'release']
    list_display_links = ['title']
    list_filter = ['author']
    date_hierarchy = 'release'
    search_fields = ['title', 'author__name']

    form = BookAdminForm

admin.site.register(Book, BookAdmin)

def application(environ, start_response):
    data = b'Hello, World!\n'
    start_response('200 OK', [
        ('Content-type', 'text/plain'),
        ('Content-Length', str(len(data)))
    ])
    return iter([data])