<!doctype html>
<html lang="en">

    <head>
        <meta charset="utf-8">

        <title>Entendendo DJANGO</title>

        <meta name="description" content="A framework for easily creating beautiful presentations using HTML">
        <meta name="author" content="Hakim El Hattab">

        <meta name="apple-mobile-web-app-capable" content="yes">
        <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">

        <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, minimal-ui">

        <link rel="stylesheet" href="reveal.js/css/reveal.css">
        <link rel="stylesheet" href="reveal.js/css/theme/solarized.css" id="theme">

        <!-- Code syntax highlighting -->
        <link rel="stylesheet" href="reveal.js/lib/css/zenburn.css">

        <!-- Printing and PDF exports -->
        <script>
            var link = document.createElement( 'link' );
            link.rel = 'stylesheet';
            link.type = 'text/css';
            link.href = window.location.search.match( /print-pdf/gi ) ? 'css/print/pdf.css' : 'reveal.js/css/print/paper.css';
            document.getElementsByTagName( 'head' )[0].appendChild( link );
        </script>

        <!--[if lt IE 9]>
        <script src="lib/js/html5shiv.js"></script>
        <![endif]-->

        <!-- personal styles -->
        <style>
            .semi-opaque {
                background-color: rgba(0, 0, 0, 0.7);
            }
        </style>
    </head>

    <body>
        <div class="reveal">
            <div class="slides">
                <section data-background='_images/django-allauth.png' data-header>
                    <h1 class='semi-opaque'>Entendendo Django</h1>
                </section>

                <section>
                    <section>
                        <h2>Projeto</h2>

                        <p>"Projeto" é como Django chama a base do sistema.</p>

                        <p>Criado com <code>django-admin startproject [PROJECTNAME] .</code>.</p>
                    </section>

                    <section>
                        <h2>Projeto: startproject</h2>

                        <pre><code class="hljs">
    .
    ├── exemplo
    │   ├── __init__.py
    │   ├── settings.py
    │   ├── urls.py
    │   └── wsgi.py
    └── manage.py
                        </code></pre>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt;</small>
                            App
                        </h2>

                        <p>
                            Dentro do projeto, para criar um app:
                        </p>

                        <pre><code class="hljs">
cd exemplo
django-admin startapp [app]
                        </code></pre>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt;</small>
                            App
                        </h2>

                        <pre><code class="hljs">

.
├── manage.py
└── exemplo
    ├── __init__.py
    ├── products
    │   ├── admin.py
    │   ├── apps.py
    │   ├── __init__.py
    │   ├── migrations
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py
                        </code></pre>
                    </section>

                    <section>
                        <h3>Outras coisas do manage.py</h3>

                        <ul>
                            <li><code>python manage.py syncdb</code>: Cria as
                                tabelas necessárias e adiciona os dados
                                necessários.</li>
                            <li><code>python manage.py makemigrations</code>:
                                Verifica alterações em modelos e gera regras
                                para conversão do banco.</li>
                            <li><code>python manage.py shell</code>: Shell de
                                acesso ao Django (na verdade, abre um
                                interpretador Python com um monte de coisas já
                                carregadas/configuradas)</li>
                            <li><code>python manage.py runserver</code>: Roda
                                um server de desenvolvimento.</li>
                        </ul>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            models.py
                        </h2>

                        <p>Definição do banco de dados para o app.</p>

                        <pre><code class="hljs">
class Product(models.Model):

    """Product information"""

    name = models.CharField('Name', max_length=40)
                        </code></pre>

                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            admin.py
                        </h2>

                        <p>Definição do admin (ou não) dos models.</p>

                        <pre><code class="hljs">
class ProductAdmin(admin.ModelAdmin):
    pass

admin.site.register(Product, ProductAdmin)
                        </code></pre>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            forms.py
                        </h2>

                        <p>Definição de formulários/formulários baseados em models.</p>

                        <pre><code class='hljs'>
class ProductForm(forms.Form):
    name = forms.CharField(label='Your name', max_length=40)
                        </code></pre>

                        <pre><code class="hljs py">
class ProductForm(ModelForm):
    class Meta:
        model = Product
                        </code></pre>

                        <p>O "label" do campo ficará com o valor do primeiro parâmetro
                        usado no field em ModelForms.</p>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            views.py
                        </h2>

                        <p>Views do app.</p>

                        <pre><code class="hljs">
def get_product(request, product_id):
    if request.method == 'GET':
        product = get_object_or_404(Product, pk=product_id)
        return render(request, 
                      'product_info.html',
                      {'product': product})
    else:
        form = ProductForm(request)
        if form.is_valid():
            form.save()

        return render(request, 
                      'product_info.html',
                      {'form': form})
                        </code></pre>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            templates/product_info.html
                        </h2>

                        <p>Na verdade, todos os templates <i>da app</i> ficam em
                            <code>templates</code>.</p>

                        <pre><code class="hljs">
{% extends 'base.html' %}
<ul>
    {% if product %}
        <li>Product name: {{ product.name }}</li>
    {% endif %}

    {% if form %}
        {{ form }}
    {% endif %}
</ul>
                        </code></pre>

                            <p>O <code>base.html</code> pode estar no <code>templates</code>
                            do projeto.</p>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            urls.py
                        </h2>

                        <p>URLs internas do app.</p>

                        <pre><code class="hljs">
from . import views

urlpatterns = [
    url(r'^(?P&lt;product_id&gt;[0-9]+)/$', views.get_product, name='get'),

]
                        </code></pre>
                    </section>

                    <section>
                        <h2>App completa!</h2>

                        <p>... só que o Django ainda não sabe que ela existe.</p>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>
                            <small>Projeto &gt;</small>
                            settings.py
                        </h2>

                        <pre><code class="hljs">
[...]
INSTALLED_APPS = (
    [...]
    'products',
    [...]
)
                        </code></pre>

                        <p>Agora o Django sabe que a App existe!</p>

                        <p class="fragment">Só não sabe como chegar lá porque faltam as URLs.</p>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt;</small>
                            urls.py
                        </h2>

                        <pre><code class="hljs">
[...]
urlpatterns = [
    [...]
    url(r'/products', include('products')),
    [...]
]
                        </code></pre>
                    </section>

                    <section>
                        <p>Agora funciona como esperado:</p>

                        <ul>
                            <li>Request de um browser chega no Django;</li>
                            <li>Consulta o urls.py base do projeto para encontrar o
                                que será executado;</li>
                            <li>Consulta o urls.py da app (no caso) para encontrar
                                a view que será executada;</li>
                            <li>Encontra a view dentro da app, que busca as informações no model;</li>
                            <li>Renderiza o template;</li>
                            <li>Retorna o template renderizado para o usuário.</li>
                        </ul>
                    </section>
                </section>

                <section>
                    <img src="_images/goodgood-but-we-must-go-deeper.jpg" alt="Go deeper"/>
                </section>

                <section>
                    <section>
                        <h2>Índices</h2>

                        <p>Cada campo pode ser indexado usando a propriedade
                            <code>db_index</code>.</p>

                        <pre><code class="hljs">
class Order(models.Model):

    """An order."""

    costumer.models.ForeignKey(User, db_index=True)
                        </code></pre>
                    </section>

                    <section>
                        <h2>Meta</h2>

                        <p>Models podem ter uma classe de "Meta" com informações adicionais:</p>

                        <pre><code class="hljs">
class Order(models.Model):
    
    """An order."""

    costumer = models.ForeignKey(User, db_index=True)
    date = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'my_orders'
        index_together = [
            ('costumer', 'date')
        ]
                        </code></pre>
                    </section>

                    <section>
                        <h2>Relationships</h2>

                        <p>Projeto &gt; App &gt; models.py</p>

                        <pre><code class="hljs">
class Product(models.Model):

    """Product information"""

    name = models.CharField(max_length=40)
    price = models.DecimalField(max_digits=6, decimal_places=2)


class Order(models.Model):

    """An order."""

    products = models.ManyToManyField(Product)
                        </code></pre>
                    </section>

                    <section>
                        <h2>"OneToMany"</h2>

                        <p>
                            Não existe relacionamento "one to many" (p.ex., um
                            pedido tem vários ítens de pedido). Para isso,
                            usa-se o <code>ForeignKey</code> na parte "many".
                        </p>

                        <pre><code class="hljs">
class Order(models.Model):

    """An order."""

    costumer = models.ForeignKey(Users)


class OrderItem(models.Model):

    """An item of an order."""

    order = models.ForeignKey(Order))metro
    product = models.ForeignKey(Product)
    quantity = models.PositiveIntegerField()
                        </code></pre>

                    </section>
                </section>

                <section>
                    <h2>Inserts</h2>

                    <pre><code class="hljs">
product = Product(name='fruit')
order = Order()
order.products.add(product)
product.save()
order.save()
                    </code></pre>
                </section>

                <section>
                    <section>
                        <h2>Queries</h2>

                        <pre><code class="hljs">
all_products = Product.objects.all()
                        </code></pre>

                        <pre><code class="hljs">
fruit = Product.objects.get(pk=1)
fruit = Product.objects.get(name='fruit')
                        </code></pre>

                        <pre><code class="hljs">
all_fruits_in_orders = Order.objects \
                       .filter(products__name__like='fruit') \
                       .distinct()
                        </code></pre>
                    </section>

                    <section>
                        <h2>Queries</h2>
                        <p><code>get</code> só pode retornar <strong>um</strong> elemento.</p>

                        <p><code>pk</code> é uma variável mágica que aponta
                            para o campo marcado como
                            <code>primary_key=True</code>; se não houver um
                            <code>primary_key</code>, o Django cria um
                            <code>IntegerField(auto_increment=True)</code>.</p>
                    </section>

                    <section>
                        <h2>Reverse Queries</h2>

                        <p>Quando é criada uma relação, o Django cria também uma
                            relação reversa entre os models.</p>

                        <pre><code class="hljs">
order = Order.objects.get(pk=1)
print order.products.all()
                        </code></pre>

                            <pre><code class="hljs">
print Products.order_set.all()
                        </code></pre>

                        <p>O nome da relacionamento reverso pode ser alterado com
                            <code>related_name</code>.</p>
                    </section>

                    <section>
                        <h2>Queries com AND</h2>

                        <p>Queries onde todas as condições devem ser
                            satisfeitas podem ser feitas passando mais
                            parametros em <code>filter</code>.</p>

                        <pre><code class="hljs">
all_expensive_fruits = Order.objects.filter(
    products__name__like='fruit',
    price__gt=1000)
                        </code></pre>
                    </section>

                    <section>
                        <h2>Queries com OR</h2>

                        <p>Para queries com OR, deve-ser usar o objeto <code>Q</code>.</p>

                        <pre><code class="hljs">
all_fruits_or_expensive = Order.objects.filter(
    Q(products__name__like='fruit') |
    Q(price__gt=1000))
                        </code></pre>
                    </section>

                    <section>
                        <h2>Q</h2>

                        <p><code>Q</code> também pode ser usado para AND e queries mais
                        complexas.</p>

                        <pre><code class="hljs">
fruit_salad = Order.objects.filter(
    Q(products__name__like='fruit') &amp;
    (Q(price__gt=1000) | Q(price=0))
                        </code></pre>

                        <p class="fragment">É possível misturar <code>Q</code>
                            com filter normal, mas existe uma questão de
                            prioridades e é melhor nem pensar em misturar os
                            dois.</p> 
                    </section> 
                </section>

                <section>
                    <section>
                        <h2>CHOICES</h2>

                        <p>É possível definir valores fixos para campos com
                            <code>choices</code>.  </p>

                        <pre><code class="hljs">
class Order(models.Model):

    """An order."""

    CHOICES = (
        ('M', 'Money'),
        ('C', 'Credit card')
    )

    products = models.ManyToManyField(Product)
    payment_type = models.CharField(max_length=1, choices=CHOICES)
                        </code></pre>

                        <p class="fragment">O primeiro valor é o valor que será
                            registrado no banco; o segundo, apresentado num
                            ModelForm.</p>
                    </section>

                    <section>
                        <h2>CHOICES</h2>

                        <p>Para as queries, é preciso pedir o valor do campo, não do display.</p>

                        <pre><code class="hljs">
credit_card_orders = Order.objects.filter(payment_type='C')
                        </code></pre>
                    </section>

                    <section>
                        <h2>CHOICES</h2>

                        <p>Para facilitar a vida, usar contantes.</p>

                        <pre><code class="hljs">
class Order(models.Model):

    """An order."""

    MONEY = 'M'
    CREDIT_CARD = 'C'

    CHOICES = (
        (MONEY, 'Money'),
        (CREDIT_CARD, 'Credit card')
    )

credit_card_orders = Order.objects.filter(
    payment_type=Order.CREDIT_CARD)
                        </code></pre>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>Fixtures</h2>

                        <p>Fixtures são arquivos JSON que o Django consegue usar
                            para preencher o banco de dados.</p>

                        <pre><code class="hljs">
[
    {
        "pk": 1,
        "model": "Products",
        "fields": {
            "name": "fruit"
        }
    }
]
                        </code></pre>
                    </section>

                    <section>
                        <h2>Fixtures em Testes</h2>

                        <p>Fixtures em testes se aplicam a suíte inteira.</p>

                        <p>Para definir que um teste usa fixtures, é usada a
                            variável <code>fixtures</code> da classe.</p>

                        <pre><code class="hljs">
class ProductTest(StaticLiveServerTestCase):
fixtures = ['products.json']
                        </code></pre>
                    </section>

                    <section>
                        <h2>Fixtures em Produção</h2>

                        <p>Para criação das tabelas de banco de dados, usa-se
                            <code>python manage.py syncdb</code>.</p>

                        <p>Se houverem fixtures a serem carregadas, essas serão
                            injetadas no banco de dados durante o
                            <code>syncdb</code>.</p>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>Signals</h2>

                        <p>Signals (sinais) são eventos gerados dentro do Django
                            para chamar funções de usuário em algumas
                            condições (normalmente relacionadas com models).</p>

                        <pre><code class="hljs">
from django.db.models.signals import pre_save
from django.dispatch import receiver
from models import Product

@receiver(post_save, sender=Product)
def after_saving_product(sender, instance, created, raw, using, update_fields):
    # ...
                        </code></pre>
                    </section>

                    <section>
                        <h2>Signals</h2>

                        <ul>
                            <li>sender = o model sendo afetado.</li>
                            <li>instance = registro sendo alterado.</li>
                            <li>created = se é um novo registro ou não.</li>
                            <li>raw = registro salvo exatamente como indicado (fixtures).</li>
                            <li>using = alías do database sendo usado.</li>
                            <li>update_fields = campos sendo salvos no
                                <code>save()</code> (None se forem todos).</li>
                        </ul>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>Mais forms</h2>

                        <pre><code class="hljs">
class ProductForm(forms.Form):
    name = forms.CharField(label='Your name', max_length=40)
                        </code></pre>

                        <p>Para usar o name:</p>

                        <pre><code class="hljs">
def get_product(request, product_id):
    if request.method == 'POST':
        form = ProductForm(request)
        if form.is_valid():
            record = Product(name=form.cleaned_data['name'])
            record.save()

        return render(request, 
                      'product_info.html',
                      {'form': form})
                        </code></pre>
                    </section>

                    <section>
                        <h2>Mais forms</h2>

                        <p><code>cleaned_data</code> é usado porque os campos podem ser alterados
                            para evitar problemas dentro do sistema.</p>

                        <p>Regras de "limpeza" estão definidas dentro dos FormFields.</p>

                        <pre><code class="hljs">
f = forms.CharField()
f.clean(True)
'True'
                        </code></pre>
                    </section>

                    <section>
                        <h2>Mais forms</h2>

                        <p>Em caso de erro, isso é indicado no form, para cada
                            campo e um dicionario global com essa
                            informação:</p>

                        <pre><code class="hljs">
form = ProductForm({'name': 'nome muito grande, com mais de 40 caracteres, o que é inválido'})
f['name'].errors        # [u'Too many characters']

f.errors                # {'name': [u'Too many characters']}
                        </code></pre>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>Templatetags</h2>

                        <p>Funções especiais para templates para apresentação de valores.</p>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt;</small>
                            templatetags/
                        </h2>

                        <p>Dentro do diretório <code>templatetags</code> do App
                            ficam os módulos com os tags.</p>

                        <p>(Lembrar de colocar o arquivo <code>__init__.py</code> para que
                            o Python detecte o diretório como um módulo).</p>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt; templatetags/</small>
                            filters.py
                        </h2>

                        <pre><code class="hljs">
def free(value):
    if value == 0:
        return _('Free')
    return value
                        </code></pre>
                    </section>

                    <section>
                        <h2>
                            <small>Projeto &gt; App &gt; templates/</small>
                            product_info.html
                        </h2>

                        <pre><code class="hljs">
{{ product.price|free }}
                        </code></pre>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>URLs/Redirects</h2>

                        <p>Redirects servem para indicar que o browser deve se
                        direcionar à outra URL.</p>

                        <p>Para referenciar URLs de outras apps (ou mesmo da
                            mesma app), deve-ser usar o método
                            <code>reverse</code>.</p>

                        <pre><code class="hljs">
from django.core.urlresolvers import reverse
from django.shortcuts import redirect

def view(request):
    # do stuff
    return redirect(reverse('app:func'))

                        </code></pre>
                    </section>
                </section>

                <section>
                    <section>
                        <h2>Testes</h2>

                        <p>Bem parecido com o módulo <code>unittest</code> do Python
                        padrão.</p>

                        <pre><code class="hljs">
import random

from django.test import TestCase

class RandomTest(TestCase):
    def test_random(self):
        """Check if random numbers return random numbers."""
        self.assertTrue(random.randint(255) != 0)
                        </code></pre>
                    </section>

                    <section>
                        <p>Testes podem acessar qualquer coisa (desde que importados):</p>

                        <ul>
                            <li>Modelos;</li>
                            <li>Views;</li>
                            <li>Requisições inteiras.</li>
                        </ul>
                    </section>

                    <section>
                        <pre><code class="hljs">
from django.test import Client
from django.test import TestCase

class RequestTest(TestCase):
    def test_retrieve_page(self):
        client = Client()
        response = client.get('/')
        self.assertTrue('success!' in response.content)
        self.assertEquals(response.status_code, 200)
        self.assertTrue('variable' in response.context)
        self.assertEqual(response.context['variable'], 'success')
                        </code></pre>
                    </section>
                </section>
            </div>
        </div>

        <script src="reveal.js/lib/js/head.min.js"></script>
        <script src="reveal.js/js/reveal.js"></script>

        <script>
            // Full list of configuration options available at:
            // https://github.com/hakimel/reveal.js#configuration
            Reveal.initialize({
                controls: true,
                progress: true,
                history: true,
                center: true,

                transition: 'slide', // none/fade/slide/convex/concave/zoom

                // Optional reveal.js plugins
                dependencies: [
                    { src: 'lib/js/classList.js', condition: function() { return !document.body.classList; } },
                    { src: 'plugin/markdown/marked.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
                    { src: 'plugin/markdown/markdown.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
                    { src: 'reveal.js/plugin/highlight/highlight.js', async: true, callback: function() { hljs.configure({languages: ['python']}); hljs.initHighlightingOnLoad(); } },
                    { src: 'reveal.js/plugin/zoom-js/zoom.js', async: true },
                    { src: 'reveal.js/plugin/notes/notes.js', async: true }
                ]
            });

        </script>

    </body>
</html>