Академический Документы
Профессиональный Документы
Культура Документы
Todos os direitos reservados. Nenhuma parte deste livro pode ser reproduzida, armazenada em um sistema de recuperação ou transmitida de qualquer
forma ou por qualquer meio, sem a prévia autorização por escrito do editor, exceto no caso de citações breves incorporados em artigos ou críticas.
Todos os esforços foram feitos na preparação deste livro para garantir a precisão das informações apresentadas. No entanto, a informação contida
neste livro é vendido sem garantia, expressa ou implícita. Nem o autor, nem Packt Publishing ou seus revendedores e distribuidores, será
responsabilizado por quaisquer danos causados ou alegadamente causados direta ou indiretamente por este livro.
Packt Publishing tem se esforçado para fornecer informações marca sobre todas as empresas e produtos mencionados neste livro através da
utilização adequada de capitais. No entanto, Packt Publishing não pode garantir a precisão das informações.
ISBN 978-1-78847-248-7
www.packtpub.com
Para minha irmã
mapt.io
MAPT é uma biblioteca digital on-line que lhe dá acesso total ao longo
5.000 livros e vídeos, bem como principais ferramentas da indústria para ajudar a planejar o seu
desenvolvimento pessoal e avançar em sua carreira. Para mais informações, por favor visite
nosso website.
Por que se inscrever?
Melhorar a sua aprendizagem com Planos de Habilidade construído especialmente para você
em www.PacktPub.com , você também pode ler uma coleção de artigos técnicos gratuitos, inscrever-se para
uma série de boletins de notícias livres, e receber descontos e ofertas exclusivas em livros e
eBooks Packt.
contribuintes
Sobre o autor
Antonio Melé é o Investir CTO da Exo e fundador da Zenx TI. Antonio tem vindo a
desenvolver projectos Django desde 2006 para clientes em várias indústrias. Ele tem
trabalhado como o CTO e como um consultor de tecnologia para várias startups de base
tecnológica, e ele conseguiu equipes de desenvolvimento a construção de projetos para
grandes empresas digitais. Antonio possui mestrado em Ciência da Computação pela
Universidad Pontificia Comillas. Seu pai inspirou sua paixão por computadores e
programação.
O que este livro cobre
Capítulo 1 , Construindo um aplicativo de blog, apresenta o quadro através da criação de um
aplicativo de blog. Você vai criar as básicos modelos de blog, visões, modelos e URLs
para exibir mensagens de blog. Você vai aprender a construir QuerySets com o Django
ORM, e você vai configurar site de administração do Django.
Capítulo 2 , Aprimorando seu Blog com recursos avançados, ensina como lidar com formas e modelos
de formulários, e-mails enviar com Django, e integrar aplicativos de terceiros. Você vai
implementar um sistema de comentários para o seu blog e permitir que seus usuários para
mensagens compartilhar via e-mail. O capítulo também orienta durante o processo de criação
de um sistema de marcação.
Capítulo 3 , Estendendo o aplicativo de blog, explora como criar tags e filtros modelo personalizado. O
capítulo também mostra como usar a estrutura de mapa do site e criar um feed RSS para suas
mensagens. Você vai completar o seu aplicativo de blog através da construção de um motor de
busca com recursos de pesquisa de texto completo do PostgreSQL.
Capítulo 4 , Construindo um Web site social, explica como construir um site social. Você vai usar a
estrutura de autenticação Django para criar visualizações de conta de usuário. Você vai
aprender como criar um modelo de perfil de usuário personalizada e construir autenticação
social no seu projeto usando grandes redes sociais.
Capítulo 6 , Rastreamento ações do usuário, mostra-lhe como construir um sistema seguidor para os
usuários. Você vai completar sua imagem site de bookmarking, criando um aplicativo de fluxo de
atividade do usuário. Você vai aprender como otimizar QuerySets, e você vai trabalhar com sinais.
Você vai integrar Redis em seu projeto para contar visualizações de imagem.
Capítulo 7 , Construir uma loja on-line, explora como criar uma loja online. Você vai construir modelos
de catálogo, e você vai criar um carrinho de compras usando sessões Django. Você vai
construir um processador de contexto para o carrinho de compras, e você vai aprender como
implementar o envio de notificações assíncronas aos usuários usando aipo.
Capítulo 9 , Estendendo sua loja, ensina como criar um sistema de cupom para aplicar descontos
para encomendas. Os shows capítulo como adicionar internacionalização ao seu projeto e
como traduzir modelos. Você também vai construir um mecanismo de recomendação
produto usando Redis.
Capítulo 11 , Renderização e cache de conteúdo, mostra-lhe como criar um sistema de registo dos
alunos e gerenciar o ingresso dos alunos em cursos. Você irá processar o conteúdo do
curso diverso e você vai aprender como usar o framework de cache.
Capítulo 12 , A construção de uma API, explora a construção de uma API RESTful para o seu
projeto usando o framework Django REST.
Capítulo 13 , Indo ao vivo, mostra como configurar um ambiente de produção usando uWSGI e
NGINX, e como protegê-lo com SSL. O capítulo explica como construir um middleware
personalizado e criar comandos de gerenciamento personalizados.
Sobre os revisores
Norbert Máté é um desenvolvedor web. Ele começou sua carreira em volta
2008. A sua primeira linguagem de programação como um desenvolvedor web profissional
foi PHP, em seguida, ele se mudou para JavaScript / Node.js e quadro Python / Django /
Django REST. Ele é apaixonado por arquitetura de software, padrões de projeto, e um
código limpo. Norbert foi o revisor de outro livro Django Django RESTful Web Services por
Packt Publishing.
Se você está interessado em se tornar um autor para Packt, visite auth ors.packtpub.com e aplicar hoje.
Temos trabalhado com milhares de desenvolvedores e profissionais de tecnologia, assim como
você, para ajudá-los a compartilhar sua visão com a comunidade global de tecnologia. Você
pode fazer uma aplicação geral, aplicar-se para um tema quente específico que estamos a
recrutar um autor para, ou enviar sua própria idéia.
Índice
Folha de rosto
Dedicação Packt
Upsell
PacktPub.com
contribuintes
Sobre o autor
Sobre os revisores
Prefácio
livro
Convenções usadas
Entrar em contato
Rever
Instalando o Django
configurações do projeto
Projetos e aplicações
Ativando o aplicativo
Criando um superusuário
criação de objetos
objetos
Usando excluir ()
Usando order_by ()
Excluindo objetos
adicionando a paginação
resumo
resumo
Instalando o PostgreSQL
consultas de ponderação
resumo
de usuário
resumo
Carregando jQuery
resumo
modelo
Usando select_related ()
Usando prefetch_related ()
Instalando Redis
resumo
configurações da sessão
expiração de sessão
carrinho de compras
processadores de contexto
Instalando Aipo
Instalando RabbitMQ
Aipo monitoramento
resumo
pagamento
pagamentos de teste
indo ao vivo
dinamicamente
Instalando WeasyPrint
resumo
traduções padrão
traduções preguiçosos
traduzindo modelos
O {% trans%} tag
O {% blocktrans%} tag
traduções distorcido
com django-parler
Instalando django-parler
local
localização Format
resumo
modelos de curso
Usando luminárias para fornecer & # xA0, os dados iniciais para modelos
Criando modelos de conteúdo diversificado
modelos abstratos
modelos de proxy
Criação de um CMS
módulos e conteúdos
Se matricular em cursos
Instalando o Memcached
Configurações de cache
monitoramento Memcached
níveis de cache
resumo
definindo serializers
autenticação de manipulação
resumo
usando PostgreSQL
Verificando seu projeto
Instalando uWSGI
Configurando uWSGI
Instalando NGINX
O ambiente de produção
Configurando NGINX
com SSL
resumo
Depois de ler este livro, você vai ter uma boa compreensão de como Django funciona
e como construir, aplicações web práticas avançadas.
Que este livro é para
Este livro é destinado a desenvolvedores com conhecimento Python que desejam aprender
Django de forma pragmática. Talvez você é completamente novo para Django, ou você já
sabe um pouco, mas você deseja obter o máximo proveito dela. Este livro vai ajudar você a
dominar áreas mais relevantes do quadro através da construção de projetos práticos a partir
do zero. Você precisa ter familiaridade com conceitos de programação, a fim de ler este livro.
Algum conhecimento prévio de HTML e JavaScript é assumido.
Para tirar o máximo proveito deste livro
Para tirar o máximo proveito deste livro, é recomendável que você tem bom
conhecimento de Python. Você também deve estar confortável com HTML e
JavaScript. Antes de ler este livro, é recomendável que você leu partes 1 a 3 da
documentação tutorial oficial do Django no https://docs.djangoproject.com/en/2.0/intro/tutorial01/ .
Faça o download dos arquivos de código de
exemplo
Você pode baixar os arquivos de código de exemplo para este livro de sua conta em www.packtpub.com
. Se você comprou este outro lugar do livro, você pode visitar www.packtpub.com/support e se registrar para
ter os arquivos por e-mail diretamente para você.
Uma vez que o arquivo é baixado, certifique-se de que você descompactar ou extrair a pasta
usando a versão mais recente de:
O pacote de código para o livro também está hospedado no GitHub em https: // Githu
b.com/PacktPublishing/Django-2-by-Example . No caso de haver uma atualização para o código, ele será
atualizado no repositório GitHub existente.
Temos também outros pacotes de código a partir do nosso rico catálogo de livros e
vídeos disponíveis no https://github.com/PacktPublishing/ . Vê-los!
Convenções usadas
Há uma série de convenções de texto utilizados ao longo deste livro.
CodeInText: Indica palavras de código em texto, nomes de tabelas de banco de dados, nomes de pastas,
nomes de arquivos, extensões de arquivos, caminhos, URLs manequim, a entrada do usuário, e alças
Twitter. Aqui está um exemplo: "Você pode desativar seu ambiente a qualquer momento com o desativar comando."
importar Publicar
admin.site.register (Post)
Quando queremos chamar a atenção para uma determinada parte de um bloco de código, as linhas ou
itens relevantes são definidos em negrito:
INSTALLED_APPS = [
'Django.contrib.admin', 'django.contrib.auth',
'django.contrib.contenttypes', 'django.contrib.sessions',
'django.contrib.messages', 'django.contrib.staticfiles',
'Blog.apps.BlogConfig',
Negrito: Indica um novo termo, uma importante palavra ou palavras que você
vê na tela. Por exemplo, palavras menus ou caixas de diálogo aparecem no texto como
este. Aqui está um exemplo: "Preencha o formulário e clique no botão Salvar".
errata: Embora tenhamos tomado todos os cuidados para garantir a precisão de nosso
conteúdo, erros acontecem. Se você encontrou um erro neste livro, ficaríamos muito gratos
se você iria relatar isso para nós. Por favor visite www.packtpub.com/submit-errata , seleção de seu livro,
clicando no link Errata Formulário de Apresentação, e inserindo os detalhes.
Pirataria: Se você se deparar com quaisquer cópias ilegais de nossos trabalhos em qualquer formulário
na Internet, ficaríamos muito gratos se você poderia nos fornecer o endereço de localização ou nome
do site. Entre em contato conosco
copyright@packtpub.com com um link para o material.
Django 2.0 requer Python versão 3.4 ou superior. Nos exemplos para este livro, vamos usar
Python 3.6.5. Se você estiver usando Linux ou MacOS X, você provavelmente tem o Python
instalado. Se você estiver usando o Windows, você pode baixar um instalador Python em https://www.python.org
/ downloads / windows / .
Se você não tiver certeza se Python está instalado no seu computador, você pode
verificar-lo digitando Pitão no shell. Se você ver algo como o seguinte, em seguida, Python
está instalado no seu computador:
Python 3.6.5 (v3.6.5: f59c0932b4, 28 de março, 2018, 03:03:55) [GCC 4.2.1 (Apple Inc. construir 5666) (ponto 3)] no
darwin Type "help", "copyright", " créditos" ou 'licença' para mais informações.
>>>
Se a sua versão Python instalada é menor do que 3,4, ou se Python não está instalado
no seu computador, baixe Python 3.6.5 do https: //www.p ython.org/downloads/ e instalá-lo .
Desde que você vai usar Python 3, você não tem que instalar um banco de dados. Esta versão
Python vem com um banco de dados embutido SQLite. SQLite é um banco de dados leve que
você pode usar com Django para o desenvolvimento. Se você planeja implantar seu aplicativo em
um ambiente de produção, você deve usar uma base de dados avançada, como PostgreSQL,
MySQL, ou Oracle. Você pode obter mais informações
sobre como obter o seu banco de dados rodando com Django na https://docs.djangoproject.com/en/2.0/topics/install/#database-installat
.
Criar um ambiente Python isolado
Recomenda-se que você usa virtualenv para criar ambientes Python isolados, de modo que você
pode usar diferentes versões de pacotes para diferentes projetos, o que é muito mais
prático do que instalar pacotes Python em todo o sistema. Outra vantagem da utilização virtualenv
é que você não vai precisar de privilégios de administração para instalar pacotes Python.
Execute o seguinte comando no seu shell para instalar
virtualenv:
virtualenv my_env
Isto irá criar uma my_env / diretório, incluindo seu ambiente Python. Quaisquer
bibliotecas Python de instalar, enquanto o seu ambiente virtual está ativo entrará no my_env
/ lib / python3.6 / site-packages
diretório.
Se o seu sistema vem com Python 2.X e tiver instalado o Python 3.x, você tem que dizer virtualenv usar
o último.
Você pode localizar o caminho onde Python 3 é instalado e usá-lo para criar o
ambiente virtual com os seguintes comandos:
O prompt shell irá incluir o nome do ambiente virtual ativa entre parênteses,
como se segue:
Em cima de virtualenv, você pode usar virtualenvwrapper. Esta ferramenta fornece wrappers que
tornam mais fácil para criar e gerenciar seus ambientes virtuais. Você pode baixá-lo https:
//virtualenvwrapper.readth edocs.io/en/latest/ .
Instalando o Django com pip
o pip sistema de gerenciamento de pacotes é o método preferido para a instalação do
Django. Python 3.6 vem com pip pré-instalado, mas você pode encontrar pip instruções de
instalação em
https://pip.pypa.io/en/stable/installing/ .
Execute o seguinte comando na janela de comandos para instalar Django com pip:
Se você obter o resultado anterior, Django foi instalado com sucesso em sua
máquina.
Django pode ser instalado em várias outras maneiras. Você pode encontrar um guia de
instalação completa no https://docs.djangoproject.com/en/2.0/topics/install/ .
Criando seu primeiro projeto
Nosso primeiro projeto Django será a construção de um blog completo. Django fornece um
comando que permite que você crie uma estrutura de arquivo de projeto inicial. Execute o seguinte
comando a partir de seu shell:
Evite dar nomes a projetos built-in módulos Python ou Django, a fim de conflitos a evitar.
meu site/
manage.py
meusite /
__init__.py
settings.py urls.py
wsgi.py
manage.py: Este é um utilitário de linha de comando usado para interagir com o seu
meu site/: Este é o diretório do projeto, que consiste nos seguintes arquivos:
urls.py: Este é o lugar onde seus padrões de URL viver. Cada URL
Para completar a configuração do projeto, vamos precisar para criar as tabelas no banco
de dados exigida pelos aplicativos listados em INSTALLED_APPS. Abra o shell e execute os
seguintes comandos:
cd mysite
Você vai notar uma saída que termina com as seguintes linhas:
OK
Aplicando auth.0008_alter_user_username_max_length ... OK aplicando
As linhas anteriores são as migrações de banco de dados que são aplicadas pelo Django. Ao
aplicar as migrações, as mesas para os pedidos iniciais são criados no banco de dados. Você
vai aprender sobre a
migrar comando de gestão no Criação e aplicação de migrações seção deste
capítulo.
Executando o servidor de desenvolvimento
Django vem com um servidor web leve para executar seu código rapidamente, sem a necessidade
de gastar tempo configurando um servidor de produção. Quando você executa o servidor de
desenvolvimento Django, ele mantém a verificação de alterações em seu código. Ele recarrega
automaticamente, libertando-o de recarregá-lo manualmente após alterações no código. No entanto,
ele pode não notar algumas ações, como adicionar novos arquivos ao seu projeto, assim você terá
que reiniciar o servidor manualmente nesses casos.
2018 - 17:17:31
Agora, aberta http://127.0.0.1:8000/ no seu browser. Você deverá ver uma página informando que o
projeto está sendo executado com sucesso, como mostrado na imagem seguinte:
A tela acima, indica que o Django está em execução. Se você der uma olhada no
seu console, você verá o OBTER solicitar realizada por seu navegador:
Cada solicitação HTTP é registrada no console do servidor de desenvolvimento. Qualquer erro que
ocorre durante a execução do servidor de desenvolvimento também será exibido no console.
Você pode indicar Django para executar o servidor de desenvolvimento em um host personalizado e porto ou
dizer-lhe para executar o projeto, carregar um arquivo de configurações diferentes, como segue:
- - settings = mysite.settings
Quando você tem que lidar com vários ambientes que requerem diferentes configurações, você pode criar
um arquivo de configurações diferentes para cada ambiente.
Lembre-se que este servidor destina-se apenas para o desenvolvimento e não é adequado
para uso em produção. A fim de colocar o Django em um ambiente de produção, você deve
executá-lo como uma aplicação WSGI usando um servidor web real, como Apache,
Gunicorn, ou uWSGI. Você pode encontrar mais informações sobre como implantar o
Django com diferentes servidores web em https://docs.djangoproject.com/en/2.0/howto/deployment/wsgi/ .
Se ele é definido como Verdade, Django irá exibir páginas de erro detalhadas quando uma
exceção não pega é jogado pelo seu aplicativo. Quando você move para um ambiente de
produção, lembre-se que você tem que configurá-lo para Falso. Nunca implantar um site em
produção com DEPURAR ligado, porque você vai expor dados sensíveis relacionados com o
projecto.
ALLOWED_HOSTS não é aplicada enquanto modo de depuração está ligada, ou quando os testes são
executados. Uma vez que você mover seu site para produção e set DEPURAR para Falso, você terá que
adicionar o seu domínio / host para essa configuração, a fim de permitir que ele para servir seu
site Django.
INSTALLED_APPS é uma configuração que você terá que editar para todos os projetos. Esta
configuração diz ao Django que aplicações estão ativas para este site. Por padrão, o
BANCOS DE DADOS é um dicionário que contém as definições para todos os bancos de dados a
ser utilizado no projeto. Deve haver sempre um banco de dados padrão. A configuração
USE_TZ diz ao Django para suporte fuso horário ativar / desativar. Django vem com
suporte para datetime timezone-aware. Esta configuração está definido para Verdade quando
Não se preocupe se você não entender muito sobre o que você está vendo. Você vai aprender
as diferentes configurações do Django nos capítulos seguintes.
Projetos e aplicações
Ao longo deste livro, você encontrará o projeto termos e aplicação mais e mais. Em
Django, um projeto é considerado uma instalação Django com alguns ajustes. Um
aplicativo é um grupo de modelos, visualizações, modelos e URLs. Aplicativos interagem
com a estrutura para fornecer algumas funcionalidades específicas e pode ser reutilizado
em vários projetos. Você pode pensar no projeto como o seu site, que contém várias
aplicações, tais como um blog, wiki, ou fórum, que pode ser utilizado por outros projetos
também.
Criando uma aplicação
Agora, vamos criar nossa primeira aplicação Django. Vamos criar um aplicativo de blog a
partir do zero. A partir do diretório raiz do projeto, execute o seguinte comando:
Isto irá criar a estrutura básica da aplicação, que se parece com isso:
blogue /
__init__.py admin.py
apps.py migrações /
__init__.py
migrações: Este diretório irá conter as migrações de banco de dados de sua aplicação.
tests.py: Isto é onde você pode adicionar testes para a sua aplicação.
views.py: A lógica de sua aplicação vai aqui; cada vista recebe um pedido de
HTTP, processa-o, e retorna uma resposta.
Projetando o esquema de dados do
blog
Vamos começar a desenhar o nosso esquema de dados do blog, definindo os modelos de dados para o
nosso blog. Um modelo é uma classe Python que subclasses
django.db.models.Model, em que cada atributo representa um campo de base de dados. Django
irá criar uma tabela para cada modelo definido no
models.py Arquivo. Quando você cria um modelo, Django fornece uma API prático para objetos de
consulta no banco de dados facilmente.
Primeiro, vamos definir uma Postar modelo. Adicione as seguintes linhas para o
models.py arquivo do blogue inscrição:
STATUS_CHOICES = (
(max_length = 250,
unique_for_date = 'publicar')
'') blog_posts
corpo models.TextField = ()
'rascunho')
class Meta:
ordenação = ( '-publish',)
def __str __ (self):
retorno self.title
Este é o nosso modelo de dados para postagens no blog. Vamos dar uma olhada nos campos nós apenas
lesma: Este é um campo destinado a ser usado em URLs. Uma bala é um rótulo curto
que contenha apenas letras, números, sublinhados ou hífens. Nós vamos usar o lesma campo
para construir, URLs bonitas SEOfriendly para os nossos posts. Nós adicionamos o
unique_for_date parâmetro para esse campo para que possamos construir URLs para as
mensagens usando sua data de publicação e lesma. Django irá evitar que várias mensagens de
autor: Este campo é uma chave estrangeira. Ele define um relacionamento muitos-para-um.
Nós estamos dizendo Django que cada post é escrito por um usuário e um usuário pode
escrever qualquer número de mensagens. Para este campo, Django irá criar uma chave
caso, estamos contando com a Do utilizador modelo do sistema de autenticação do Django. o on_delete
Esta não é específico para Django; é um padrão SQL. utilização CASCATA, que especificam
que quando o usuário referenciado é excluído, o banco de dados também excluirá seus
posts relacionados. Você pode dar uma olhada em todas as opções possíveis no https://docs.djangoproject.com/en/2.
publicar: Este datetime indica quando o artigo foi publicado. Usamos fuso horário do
Django agora método como o valor padrão. Isso retorna a data e hora atual em um
formato de fuso horário-aware. Você pode pensar nisso como uma versão fuso
criada: Este datetime indica quando o cargo foi criado. Como estamos
usando auto_now_add aqui, a data será salvo automaticamente ao criar um
objeto.
Atualizada: Este datetime indica a última vez que o post foi atualizado. Como
estamos usando auto_now aqui, a data será atualizado automaticamente ao
salvar um objeto.
parâmetro, então o valor deste campo só pode ser definida como uma das opções
dadas.
Django vem com diferentes tipos de campos que você pode usar para definir seus
modelos. Você pode encontrar todos os tipos de campo em https://docs.djangoproject.com/en/2.0/ref/models/fields/
.
o meta classe dentro do modelo contém metadados. Nós dizemos Django para resultados da
classificação no publicar campo em ordem decrescente por padrão quando consulta o banco de dados.
Nós especificar ordem decrescente usando o prefixo negativo. Ao fazer isso, posts publicados
recentemente aparecerá primeiro.
O __ str __ () método é a representação legível padrão do objeto. Django vai usá-lo em
muitos lugares, como o site de administração.
Se você vem usando Python 2.x, nota que, em Python 3, todas as cordas são nativamente considerado
Unicode e, portanto, só usamos o __ str __ () método. O __ Unicode __ () método é obsoleto.
Ativando o aplicativo
Para que o Django se manter a par da nossa aplicação e ser capaz de criar tabelas de
banco de dados para os seus modelos, temos que ativá-lo. Para fazer isso, edite o settings.py arquivo
e add blog.apps.BlogConfig ao
INSTALLED_APPS configuração. Deve olhar como este:
INSTALLED_APPS = [
'Django.contrib.admin', 'django.contrib.auth',
'django.contrib.contenttypes', 'django.contrib.sessions',
'django.contrib.messages', 'django.contrib.staticfiles',
'Blog.apps.BlogConfig',
o BlogConfig classe é a sua configuração do aplicativo. Agora o Django sabe que o nosso
aplicativo está ativo para este projeto e será capaz de carregar seus modelos.
Criação e aplicação de
migrações
Agora que temos um modelo de dados para os nossos posts, vamos precisar de uma tabela de
banco de dados para ele. Django vem com um sistema de migração que rastreia as alterações
feitas aos modelos e permite propagar-los para o banco de dados. o migrar comando aplica
migrações para todos os aplicativos listados em INSTALLED_APPS; ele sincroniza o banco de dados com
os modelos atuais e migrações existentes.
Primeiro, você precisa criar uma migração inicial para o nosso Postar modelo. No diretório
raiz do seu projeto, execute o seguinte comando:
Vamos dar uma olhada no código SQL que o Django irá executar no banco de dados
para criar a tabela para o nosso modelo. o sqlmigrate comando leva migração nomes e retorna
o seu SQL sem executá-lo. Execute o seguinte comando para inspecionar a saída SQL
da nossa primeira migração:
python manage.py sqlmigrate blogue 0001
INÍCIO;
- -
- -
CREATE TABLE "blog_post" ( "id" inteiro NOT NULL PRIMARY KEY AUTOINCREMENT, varchar "título" (250) NOT NULL, varchar
"bala" (250) NOT NULL, "corpo" texto não NULL, "publicar" datetime NOT NULL, "criou" datetime NOT NULL, "updated" datetime
NOT NULL, varchar "status" (10) NOT NULL, "author_id" inteiro não referências nulas "AUTH_USER" ( "id"));
A saída exata depende do banco de dados você está usando. A saída anterior é gerado
para SQLite. Como você pode ver na saída anterior, Django gera os nomes de tabela,
combinando o nome do aplicativo e o nome em minúsculas do modelo ( blog_post), mas você
também pode especificar um nome de banco de dados personalizado para o seu modelo na
meta classe do modelo usando o db_table atributo. Django cria uma chave primária automaticamente
para cada modelo, mas você também pode substituir esse especificando primary_key = True em um de
seus campos do modelo. A chave primária padrão é uma identidade coluna, que consiste de um
número inteiro que é incrementado automaticamente. Esta coluna corresponde ao identidade campo
que é automaticamente adicionado aos seus modelos.
Vamos sincronizar nosso banco de dados com o novo modelo. Execute o seguinte comando para
aplicar as migrações existentes:
Você vai ter uma saída que termina com a seguinte linha:
Se você editar o seu models.py arquivo, a fim de adicionar, remover ou modificar campos dos modelos
existentes, ou se você adicionar novos modelos, você terá que criar uma nova migração usando o makemigrations
comando. A migração permitirá Django para acompanhar as mudanças do modelo. Então, você vai
ter que aplicá-lo com o migrar comando para manter o banco de dados em sincronia com os seus
modelos.
Criando um site de administração para os
seus modelos
Agora que já definiu o Postar modelo, vamos criar um site de administração simples de gerenciar
seus posts. Django vem com uma interface built-in de administração que é muito útil para editar
o conteúdo. O site de administração do Django é construído dinamicamente, lendo seus
metadados modelo e fornecendo uma interface pronta para produção para edição de conteúdo.
Você pode usá-lo para fora da caixa, configurar como deseja que os seus modelos a serem
exibidos na mesma.
Você verá a seguinte saída; digite seu nome de usuário desejado, e-mail e
senha, como segue:
o Grupo e Do utilizador modelos que você vê na imagem anteriores fazem parte da estrutura
de autenticação Django localizado na
django.contrib.auth. Se você clicar em Users, você verá o usuário criado anteriormente. o Postar modelo
do seu blogue aplicação tem uma relação com esse Do utilizador modelo. Lembre-se que é uma
relação definida pela autor campo.
Adicionando seus modelos para o site de
administração
Vamos adicionar seus modelos de blog para o site de administração. Edite o
admin.py arquivo de sua blogue aplicação e torná-lo parecido com este:
importar Publicar
admin.site.register (Post)
Agora, recarregue o site de administração no seu browser. Você deverá ver o seu
Postar modelar no site admin, como segue:
Isso foi fácil, certo? Quando você registrar um modelo no site de administração do
Django, você tem uma interface amigável gerada pela
introspecção seus modelos que permite listar, editar, criar e objetos de exclusão em uma
maneira simples.
Clique no link Adicionar ao lado de Mensagens para adicionar um novo post. Você vai notar a
forma criar esse Django tem gerado dinamicamente para o seu modelo, como mostrado na
imagem seguinte:
Django utiliza diferentes elementos do formulário para cada tipo de campo. Mesmo campos
complexos, tais como DateTimeField, são exibidos com uma interface fácil, como um selecionador de
data JavaScript.
Preencha o formulário e clique no botão SAVE. Você deve ser redirecionado para a
página de postagem lista com uma mensagem bem-sucedida e o cargo recém-criado,
como mostra a imagem a seguir:
Personalizar a forma como os modelos são
exibidos
Agora, vamos dar uma olhada em como personalizar o site de administração. Edite o admin.py arquivo
do seu aplicativo de blog e alterá-lo, como segue:
importar Publicar
@ Admin.register (Post)
'Status')
Nós estamos dizendo o site de administração do Django que o nosso modelo é registado no
site administrador usando uma classe personalizada que herda de ModelAdmin. Nesta classe,
podemos incluir informações sobre como exibir o modelo no site de administração e como
interagir com ele. o list_display
atributo permite que você defina os campos de seu modelo que você deseja exibir na
página de administração lista de objetos. O @ admin.register () decorador executa a mesma
função que o admin.site.register () funcionar temos substituído, registrando o ModelAdmin classe que
decora.
Vamos personalizar o modelo de administração com mais algumas opções, usando o seguinte código:
@ Admin.register (Post)
'Status')
Retorno ao seu navegador e recarregue a página pós lista. Agora, ele será parecido com este:
Você pode ver que os campos exibidos na página de pós lista são aqueles especificados
no list_display atributo. A página da lista agora inclui uma barra lateral direita que lhe permite
filtrar os resultados por campos incluídos no list_filter atributo. A barra de pesquisa apareceu
na página. Isto é porque nós definimos uma lista de campos pesquisáveis utilizando o search_fields
atributo. Logo abaixo da barra de pesquisa, existem links de navegação para navegar
por uma hierarquia de data: este foi definido pela date_hierarchy atributo. Você também pode
ver que as mensagens são ordenados por Estado e publicar colunas por padrão. Nós
especificamos a ordem padrão usando o encomenda atributo.
Agora, clique em Adicionar link do post. Você também vai notar algumas mudanças aqui.
Conforme você digita o título de um novo post, o lesma campo é preenchido automaticamente.
Temos dito Django para preencher previamente o lesma campo com a entrada do título campo usando o prepopulated_fields
atributo. Além disso, agora, a autor campo é exibido com uma pesquisa widget que pode escalar
muito melhor do que um drop-down selecione entrada quando você tem milhares de usuários,
como mostrado na imagem seguinte:
Com algumas linhas de código, nós ter personalizado a forma como o nosso modelo é exibido
no site de administração. Há muitas maneiras de personalizar e estender site de administração
do Django. Você vai aprender mais sobre isso mais tarde neste livro.
Trabalhando com QuerySet e
gestores
Agora que você tem um site de administração totalmente funcional para gerenciar o conteúdo do
seu blog, que é hora de aprender a recuperar as informações do banco de dados e interagir com
ele. Django vem com uma abstração API poderoso banco de dados que permite criar, recuperar,
atualizar e objetos de exclusão facilmente. o Django mapeador objeto-relacional é compatível
com o MySQL, PostgreSQL, SQLite e Oracle. Lembre-se que você pode definir o banco de dados
de seu projeto no BANCOS DE DADOS definição de seus projeto settings.py Arquivo. Django pode trabalhar com
vários bancos de dados ao mesmo tempo, e você pode programar roteadores de banco de dados
para criar esquemas de roteamento personalizadas.
Depois de ter criado seus modelos de dados, o Django lhe dá uma API livre para interagir com
eles. Você pode encontrar a referência de modelo de dados da documentação oficial
https://docs.djangoproject.com/en/2.0/ref/models/ .
criação de objetos
Abra o terminal e execute o seguinte comando para abrir o shell Python:
>>> post.save ()
Vamos analisar o que este código faz. Primeiro, vamos recuperar o do utilizador
objeto com o nome de usuário admin:
o obter() método permite recuperar um único objeto do banco de dados. Note que este método
espera um resultado que corresponda à consulta. Se nenhum resultado for retornado pelo
banco de dados, este método irá gerar um Não existe exceção, e se o banco de retornos mais
de um resultado, ele vai levantar uma MultipleObjectsReturned exceção. Ambas as exceções são
atributos da classe de modelo que a consulta está sendo realizada por diante.
Então, criamos um Postar exemplo, com um título personalizado, lesma, e corpo, e vamos definir o
usuário que anteriormente recuperado como o autor do
postar:
post = Post (title = 'Outro post', slug = 'outro post', body = 'Post corpo.', autor = user)
Por fim, salvar o Postar objecto para a base de dados utilizando o Salve •()
método:
post.save ()
Os executa uma acção precedentes INSERIR instrução SQL nos bastidores. Vimos como criar um
objeto na memória em primeiro lugar e, em seguida, persistem-lo para o banco de dados, mas
também podemos criar o objeto e persistem-lo no banco de dados em uma única operação
usando o crio()
método, como se segue:
Post.objects.create (title = 'Mais um post', slug = 'one-more-post', body = 'Post corpo.', Autor = user)
objetos de atualização
Agora, mudar o título do post para algo diferente e salvar o objeto novamente:
>>> post.save ()
As alterações feitas ao objeto não são persistentes no banco de dados até você chamar o Salve •() método.
recuperar objetos
o Django mapeamento objeto-relacional (ORM) é baseado em QuerySets. Um QuerySet é
uma coleção de objetos a partir de seu banco de dados que podem ter vários filtros para
limitar os resultados. Você já sabe como recuperar um único objeto do banco de dados
usando o obter()
método. Nós ter acessado este método usando Post.objects.get (). Cada modelo Django tem pelo
menos um gerente, eo gerente padrão é chamado objetos. Você ganha um QuerySet objeto
usando seu gerenciador de modelo. Para recuperar todos os objetos de uma tabela, basta
usar o todos() método no padrão objetos gerente, como este:
É assim que criar um QuerySet que retorna todos os objetos no banco de dados. Note que
este QuerySet ainda não foi executado. QuerySets Django são preguiçoso; eles só são
avaliadas quando eles são forçados a. Este comportamento faz com que QuerySets muito
eficiente. Se não definir a QuerySet a uma variável, mas, em vez escrevê-lo diretamente no
shell Python, a instrução SQL do QuerySet é executado porque forçá-lo a resultados de
saída:
>>> Post.objects.all ()
Utilizando o filtro () Método
Para filtrar um QuerySet, você pode usar o filtro() método do gestor. Por exemplo, podemos
recuperar todas as mensagens publicadas no ano de 2017 usando o seguinte QuerySet:
Você também pode filtrar por vários campos. Por exemplo, podemos recuperar todos os posts
publicados em 2017 pelo autor com o nome de usuário admin:
As consultas com métodos de campo de pesquisa são construídos usando dois sublinhados, por exemplo, publish__year, mas
a mesma notação também é usado para acessar os campos dos modelos relacionados, tais como author__username.
Usando excluir ()
Você pode excluir certos resultados do seu QuerySet usando o
excluir() método do gestor. Por exemplo, podemos recuperar todos os posts publicados em
2017 cujos títulos não começar com Por quê:
Post.objects.order_by ( 'título')
ordem crescente está implícita. Você pode indicar ordem decrescente com um prefixo sinal
negativo, como este:
Note-se que Excluindo objetos também irá excluir quaisquer relações de dependência para
ForeignKey objectos definidos com on_delete definido como CASCATA.
Quando QuerySets são avaliados
Você pode concatenar tantos filtros quanto você gosta de um QuerySet, e você não vai bater
o banco de dados até que o QuerySet é avaliado. QuerySets são avaliados somente nos
seguintes casos:
E se
Criando gerentes modelo
Como já mencionado anteriormente, objetos é o gerenciador padrão de cada modelo que recupera todos os
objetos no banco de dados. No entanto, também pode definir gerentes personalizados para os nossos
modelos. Vamos criar um gerenciador customizado para recuperar todas as mensagens com o Publicados status.
Há duas maneiras de adicionar gestores para seus modelos: você pode adicionar
métodos gerente extras ou modificar QuerySets gerente iniciais. O primeiro método
fornece uma API QuerySet, como Post.objects.my_manager (), e este último lhe oferece Post.my_manager.all
(). O gerente nos permitirá recuperar mensagens usando Post.published.all ().
Edite o models.py arquivo de sua blogue aplicativo para adicionar o gerente personalizado:
self) .get_queryset () \
# . . .
o get_queryset () Método de um gerente retorna o QuerySet que será executado. Nós substituir esse
método para incluir o nosso filtro personalizado na QuerySet final. Nós definimos nosso
gerente de costume e acrescentou que para o Postar modelo; agora podemos usá-lo para realizar
consultas. Vamos testá-lo.
Agora, você pode recuperar todos os posts publicados cujos começa título com Quem
usando o seguinte comando:
Primeiro, vamos criar nossos pontos de vista de aplicação, então vamos definir um padrão de
URL para cada vista, e, finalmente, vamos criar modelos HTML para renderizar os dados
gerados pelos pontos de vista. Cada vista tornará um modelo passando variáveis para ele e
retornará uma resposta HTTP com a saída renderizada.
Criação de lista e detalhe visualizações
Vamos começar criando uma visualização para exibir a lista de mensagens. Edite o
views.py arquivo de sua blogue aplicação e torná-lo parecido com este:
(pedido,
Mensagens})
Você acabou de criar sua primeira vista Django. o post_list vista leva o
solicitação objeto como o único parâmetro. Lembre-se que este parâmetro é exigido por todos os pontos
de vista. Neste ponto de vista, estamos recuperando todas as mensagens com o Publicados status
usando o Publicados gerente que criou anteriormente.
Finalmente, estamos usando o render () atalho fornecido pelo Django para renderizar a lista de
mensagens com o modelo dado. Esta função recebe o solicitação objeto, o caminho do modelo, e
as variáveis de contexto para tornar o modelo dado. Ele retorna um HttpResponse objeto com o texto
processado (normalmente, o código HTML). o render () atalho leva o contexto pedido em
consideração, de modo que qualquer conjunto de variáveis por processadores de contexto
molde é acessível pelo modelo dado. processadores contexto do template são apenas
chamáveis que as variáveis set para o contexto. Você vai aprender como usá-los em Capítulo 3 , Estendendo
o aplicativo de blog.
Vamos criar uma segunda visão para exibir um único post. Adicione a seguinte função ao views.py
Arquivo:
post_detail def (request, ano, mês, dia, post):
publish__day = dia)
Esta é a visão pós detalhes. Essa visão leva ano mês dia, e postar
parâmetros para recuperar um post publicado com a lesma dada e data. Note que
quando criamos o Postar modelo, nós adicionamos a
unique_for_date parâmetro para o lesma campo. Desta forma, podemos garantir que haverá apenas um post
com uma lesma para uma determinada data e, assim, podemos recuperar mensagens individuais
com data e lesma. Na vista de detalhes, usamos o get_object_or_404 () atalho para recuperar o posto
desejado. Esta função recupera o objeto que coincide com os parâmetros dados ou lançamentos
de um HTTP 404 (não encontrado) exceção se nenhum objeto foi encontrado. Finalmente,
usamos o render () atalho para tornar o pós recuperadas usando um modelo.
Adicionando padrões de URL para os seus pontos
de vista
padrões de URL permitem mapear URLs para vistas. Um padrão de URL é composto por um
padrão de corda, uma visão, e, opcionalmente, um nome que lhe permite nomear o URL em
todo o projeto. Django percorre cada padrão de URL e pára no primeiro aquele que
corresponde ao URL solicitado. Em seguida, o Django importa o ponto de vista do padrão de
URL correspondente e executa-lo, passando uma instância do HttpRequest
visualizações de importação
app_name = 'blog'
urlpatterns = [
# visualizações pós
caminho ( '', views.post_list, name = 'post_list'), caminho ( '<int: ano> / <int: mês> / <int: Dia> /
views.post_detail, name =
'post_detail'),
No código anterior, definimos um namespace aplicação com o nome do aplicativo variável. Isso
nos permite organizar URLs pela aplicação e usar o nome quando se refere a eles. Nós
definimos dois padrões diferentes usando o caminho() função. O primeiro padrão de URL
não leva quaisquer argumentos e é mapeado para o post_list Visão. O segundo padrão tem
as seguintes quatro argumentos e é mapeado para o
post_detail Visão:
ano: Requer um número inteiro
Usamos colchetes para capturar os valores da URL. Qualquer valor especificado no padrão
de URL como < parâmetro> é capturada como uma string. Usamos conversores caminho, como < int:
ano>, para especificamente corresponder e retornar um inteiro e < lesma: pós> para combinar
especificamente uma lesma (uma string consistindo de letras ASCII ou números, mais o hífen
e caracteres de sublinhado). Você pode ver todos os conversores caminho fornecido pelo
Django em https://docs.djangoproject.com/en/2.0/topics/http/urls/
# percursoras conversores .
Se estiver usando caminho() e conversores não é suficiente para você, você pode usar re_path () em
vez de definir padrões de URL complexos com Python expressões regulares. Você pode
aprender mais sobre a definição de padrões de URL com expressões regulares em https://docs.djangoproject.com/en/2.0/
ref / urls / # django.urls.re_path . Se você não tenha trabalhado com expressões regulares antes, você pode
querer dar uma olhada no HOWTO de Expressões Regulares localizado em https://docs.python.org/3/howto/regex.html
primeiro.
criando um urls.py arquivo para cada aplicativo é a melhor maneira de tornar seus aplicativos reutilizáveis por outros
projetos.
Agora, você tem que incluir os padrões de URL do blogue aplicação nos principais
padrões de URL do projeto. Edite o urls.py arquivo localizado na meu site diretório do seu
projeto e torná-lo parecido com o seguinte:
urlpatterns = [
Caminho ( 'admin /', admin.site.urls),
O padrão de URL nova definido com incluir refere-se aos padrões de URL definidos no
aplicativo de blog para que elas sejam incluídas no
blogue / caminho. Nós incluímos esses padrões sob o namespace blog.
Namespaces tem que ser único em todo o seu projeto. Mais tarde, vamos nos referir a
nossos URLs de blog facilmente, incluindo o namespace, construí-las, por exemplo, Blog:
post_list e Blog: post_detail. Você pode aprender mais sobre namespaces URL no https://docs.djangoproject.com/en/2.
0 / temas / http / urls / # url-namespaces .
URLs canônicas para modelos
Você pode usar o post_detail URL que você definiu na seção anterior para construir a
URL canônica para Postar objetos. A convenção em Django é adicionar um get_absolute_url () método
para o modelo que retorna a URL canônica do objeto. Para este método, vamos
utilizar o marcha ré() método que permite que você construa URLs pelo seu nome e
passando os parâmetros opcionais. Editar seu
# . . .
args = [self.publish.year,
self.publish.month,
self.publish.day, self.slug])
Nós vamos usar o get_absolute_url () método em nossos modelos de vincular a lugares específicos.
A criação de modelos para os seus pontos de
vista
Criamos pontos de vista e padrões de URL para o blogue aplicação. Agora, é hora de adicionar
modelos para mensagens de exibição de uma maneira user-friendly.
modelos/
blogue /
pós base.html /
list.html detail.html
A estrutura anterior será a estrutura do arquivo para os nossos modelos. o base.html arquivo
irá incluir a principal estrutura HTML do site e dividir o conteúdo para a área de
conteúdo principal e uma barra lateral. o list.html e detail.html ficheiros receber do base.html
Django tem um modelo de linguagem poderosa que permite que você especifique como os
dados são exibidos. Baseia-se template tags, variáveis de modelo, e filtros de templates:
<head>
<Title> {% title bloco%} {% endblock%} </ title> <link href = "{% estática "css / blog.css" %}" rel =
<Div id = "content">
{% De conteúdo bloco%} {%
{% Carga estática%} diz ao Django para carregar o estático tags de modelos que são fornecidos
pela django.contrib.staticfiles aplicação, que está contido no INSTALLED_APPS configuração. Depois de
carregá-lo, você é capaz de usar o {% % Static} filtro de template ao longo deste modelo.
Com este filtro modelo, você pode incluir arquivos estáticos, como o blog.css
arquivo, que você vai encontrar no código deste exemplo sob a estático/
diretório do blogue aplicação. copie o estático/ diretório do código que vem junto com este
capítulo na mesma localização do seu projeto para aplicar as folhas de estilo CSS.
Você pode ver que há dois {% quadra %} Tag. Estes dizem Django que queremos definir um
bloco nessa área. Modelos que herdam a partir desse modelo podem preencher os blocos
com conteúdo. Nós definimos um
bloco chamado título e um bloco chamado conteúdo.
{% De conteúdo bloco%}
mensagens%}
<H2>
endblock%}
Abra o shell e executar o python manage.py runserver comando para iniciar o servidor de
desenvolvimento. Aberto http://127.0.0.1:8000/blog/ em seu navegador, e você vai ver tudo
funcionando. Note que você precisa ter alguns posts com o status Publicado
mostrar-lhes aqui. Você deve ver algo como isto:
Em seguida, editar Vamos a post / detail.html Arquivo:
Agora, você pode retornar ao seu navegador e clique em um dos títulos pós para dar
uma olhada na vista de um posto detalhes. Você deve ver algo como isto:
Dê uma olhada na URL-lo deve ser / blog / 2017/12/14 / que-foi-djangoreinhardt /. Nós projetamos URLs
SEO-friendly para os nossos posts.
adicionando a paginação
Quando você começar a adicionar conteúdo ao seu blog, você vai logo perceber que você precisa para
dividir a lista de mensagens em várias páginas. Django tem uma classe de built-in de paginação que
permite gerenciar dados paginada facilmente.
Edite o views.py arquivo do blogue aplicação para importar as classes Paginator Django
e modificar o post_list ver, como segue:
PageNotAnInteger
object_list = Post.published.all ()
tentar:
PageNotAnInteger:
paginator.page (paginator.num_pages)
página,
'posts': Mensagens})
Agora, temos que criar um modelo para exibir o paginador para que ele possa ser incluído
em qualquer modelo que usa a paginação. No
modelos/ pasta do blogue aplicação, criar um novo arquivo e nomeá-la pagination.html. Adicione o
seguinte código HTML para o arquivo:
{% If% page.has_previous}
{% If page.has_next%}
<a href="?page={{ page.next_page_number }}"> Próxima </a> {% endif%} </ span> </ div>
{% De conteúdo bloco%}
. . .
{% Endblock%}
Desde o Página objeto estamos passando para o modelo é chamado Postagens, que incluem o modelo
de paginação no modelo de lista post, passando os parâmetros para torná-lo corretamente.
Você pode seguir este método para reutilizar o modelo de paginação em vista paginada de
diferentes modelos.
Agora, aberta http://127.0.0.1:8000/blog/ no seu browser. Você deverá ver a paginação na parte
inferior da lista de correios e deve ser capaz de navegar através de páginas:
Usando visualizações baseadas em classe
vista à base de classe são uma forma alternativa para implementar vistas como Python objectos,
em vez de funções. Desde um ponto de vista é uma função que recebe uma solicitação da web e
retorna uma resposta web, você também pode definir seus pontos de vista como métodos de
classe. Django fornece classes vista base para este. Todos eles herdam da Visão classe, que alças
HTTP despacho método e outras funcionalidades comuns.
vistas à base de classe oferecem vantagens sobre os pontos de vista baseados em função para alguns casos
código de organização relacionada com métodos HTTP, tais como GET, POST,
Usando herança múltipla para criar classes vista reutilizáveis (também conhecido
como mixins)
Você pode dar uma olhada em uma introdução à vista com base na classe de https: /
/docs.djangoproject.com/en/2.0/topics/class-based-views/intro/ .
Vamos mudar a nossa post_list vista para uma visão baseada em classes de usar o genérico Exibição de lista oferecido
pelo Django. Esta visão de base permite-lhe objetos da lista de qualquer tipo.
'postos' paginate_by = 3
Este ponto de vista com base em classes é análogo ao anterior post_list Visão. No código
anterior, estamos dizendo Exibição de lista fazer as seguintes coisas:
definir um queryset atributo, poderíamos ter especificado model = Publicar e Django teria
construído o genérico
context_object_name.
Agora, abra o urls.py arquivo de sua blogue aplicação, comentar o anterior post_list URL padrão,
e adicionar um novo padrão de URL usando o PostListView classe, como segue:
urlpatterns = [
# visualizações pós
caminho ( '<int: ano> / <int: mês> / <int: Dia> / <lesma: pós> /',
views.post_detail, name =
'post_detail'),
Aberto http://127.0.0.1:8000/blog/ no seu navegador e verificar se tudo funciona da mesma forma que com a
anterior post_list Visão. Este é um exemplo simples de uma visão baseada em classes que usa uma
classe genérica fornecida pelo Django. Você vai aprender mais sobre visualizações baseadas
em classe em Capítulo 10 , Construir uma plataforma de e-Learning, e capítulos sucessivos.
resumo
Neste capítulo, você aprendeu os fundamentos do framework web Django através da
criação de uma aplicação básica blog. Você desenhou os modelos de dados e aplicado
migrações ao seu projeto. Você criou os pontos de vista, modelos e URLs para o seu
blog, incluindo objeto paginação.
No próximo capítulo, você vai aprender como melhorar o seu aplicativo de blog com um sistema de
comentário e funcionalidade marcação e permitir que seus usuários para mensagens de compartilhamento
por e-mail.
Aprimorando seu Blog com
funcionalidades avançadas
No capítulo anterior, você criou um aplicativo básico blog. Agora, você vai transformar sua
aplicação em um blog totalmente funcional com recursos avançados, como a partilha de
mensagens por e-mail, adicionando comentários, marcar mensagens, e recuperar mensagens por
semelhança. Neste capítulo, você vai aprender os seguintes tópicos:
Crie um formulário para que os usuários preencher seu nome e e-mail, o destinatário
Criar uma vista no views.py arquivo que lida com os dados postados e envia o
e-mail
blog
Primeiro, crie um forms.py arquivo dentro do diretório de sua blogue aplicação e torná-lo parecido
com este:
widget de forms.Textarea =)
Esta é a sua primeira forma Django. Dê uma olhada no código. Nós criamos uma forma
herdando a base Formato classe. Usamos diferentes tipos de campos para Django a campos
Validar conformidade.
Os formulários podem residir em qualquer lugar em seu projeto Django. A convenção é colocá-los dentro
de um forms.py arquivo para cada aplicação.
o nome campo é CharField. Este tipo de campo é processado como um < input type = "text"> elemento
HTML. Cada tipo de campo tem um padrão widget que determina como o campo é
processado em HTML. O Widget de padrão pode ser substituído com o ferramenta atributo. No comentários
campo, usamos um textarea Widget para exibi-lo como um < textarea> elemento HTML em vez do
padrão < input> elemento.
se request.method == 'POST':
form.cleaned_data
# . . . enviar email
outro:
formar = EmailPostForm ()
'Forma': forma})
Nós definimos a post_share ver que leva o solicitação e o objeto post_id variável como
parâmetros.
status.
Nós usamos a mesma visão tanto para exibir o formulário inicial e processamento
OBTER pedido, uma forma vazia tem de ser apresentado, e se conseguirmos um POSTAR
pedido, o formulário é enviado e precisa ser processado. Por isso, usamos request.method
== 'POST' para distinguir entre os dois cenários.
crie um novo Formato exemplo que irá ser utilizado para exibir a forma vazia
no modelo:
formar = EmailPostForm ()
criar uma forma exemplo usando os dados apresentados que está contido
em request.POST:
se request.method == 'POST':
é válido() método. Este método valida os dados introduzidos na forma e retornos Verdade se
todos os campos contêm dados válidos. Se qualquer campo contém dados inválidos,
no modelo.
valores.
Se os seus dados formulário não validarem, cleaned_data conterá somente os campos válidos.
Agora, vamos aprender como enviar e-mails usando Django para colocar tudo junto.
Enviar e-mails com Django
Enviar e-mails com Django é bastante simples. Primeiro, você precisa ter um servidor
SMTP local ou definir a configuração de um servidor SMTP externo, adicionando as
seguintes definições no
settings.py arquivo do seu projeto:
Se você não pode usar um servidor SMTP, você pode dizer Django a e-mails de gravação para
o console, adicionando a seguinte configuração para o settings.py Arquivo:
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
Ao usar essa configuração, o Django saída de todos os e-mails para o shell. Isto é muito
útil para testar sua aplicação sem um servidor SMTP.
Se você quiser enviar e-mails, mas você não tem um servidor SMTP local, você provavelmente
pode usar o servidor SMTP do seu provedor de serviços de e-mail. A configuração de exemplo a
seguir é válido para o envio