A melhor forma de aprender Django, ou qualquer habilidade, é aplicando o conhecimento que você possui criando projetos funcionais.
Django é o framework de desenvolvimento web Python mais usado. Seus recursos integrados e a extensa quantidade de pacotes de terceiros o tornaram um dos frameworks da Web mais amados em todo o mundo.
É rápido, confiável e possui muitos recursos integrados. Por exemplo, um sistema de autenticação hole, que permite que você foque nas principais funcionalidades do seu app. Além disso, você pode instalar pacotes externos para realizar tarefas ainda mais complexas, como Django-allauth, que permite registrar usuários com suas contas sociais.
Mas vamos expor alguns fatos. Django é uma estrutura tão grande que às vezes é difícil começar a usá-la.
Então hoje você vai construir do zero uma aplicação Django totalmente funcional.
Ao final deste tutorial, você:
- Escreveu um aplicativo encurtador de URL
- Entenda o padrão Django MVT
- Ter aprendido o fluxo de trabalho de criação de um projeto
últimas postagens
Pré requisitos
Todos os requisitos a seguir são opcionais e ajudarão você a acompanhar o tutorial. Mas se você não tem experiência com nenhum desses, não se preocupe. O passo mais importante é o primeiro.
- Compreensão básica dos comandos do UNIX (ls, cd, rm, touch)
- Compreensão básica das classes e funções do Python
- Python instalado no seu computador (Talvez óbvio, mas tive que incluí-lo)
- Seria ótimo se você já tivesse construído algo com Django
Todo o código de trabalho estará disponível neste repositório Github.
Agora que você já tem os conceitos anteriores bem claros, vamos entrar no assunto.
declaração do projeto
Neste tutorial, você criará um encurtador de URL. Basicamente, um encurtador de URL é um serviço que pega um URL longo e o transforma em um compacto.
Por exemplo, se você deseja compartilhar um tweet e incluir um link para seu site, mas está enfrentando o limite de caracteres, pode usar um encurtador de URL.
Vamos ver com um gráfico.
Como você pode ver, o encurtador de URL obtém um URL longo e retorna um curto. Isso é exatamente o que você vai construir hoje.
Com este projeto, você praticará o uso do padrão MVT, aprenderá os fundamentos do design de banco de dados com modelos Django e aprenderá como mostrar informações ao usuário por meio de visualizações, URLs e modelos.
Estrutura de um projeto Django
Basicamente, um site Django é construído sobre um único projeto e vários aplicativos separados. Cada um desses apps tem uma funcionalidade específica e é capaz de funcionar sozinho.
Vamos imaginar uma aplicação web complexa como Stackoverflow. Sua funcionalidade é baseada em dois aspectos principais.
- Gerenciamento de usuários: login, logout, reputação, permissões
- Fórum: Perguntas, respostas, tags, filtros
Então, seguindo a estrutura do site Django, o projeto seria nomeado StackOverflow, que possui dois aplicativos principais. O aplicativo dos usuários e o aplicativo do fórum.
Cada um desses aplicativos possui funcionalidade independente. Isso significa que ambos contêm todo o código necessário para funcionar corretamente.
Isso inclui modelos (estrutura de banco de dados), visualizações (solicitações e respostas), padrões de URL específicos e, é claro, modelos e arquivos estáticos (imagens, CSS, JavaScript). Isso significa que qualquer aplicativo Django pode ser reutilizado, pois eles são capazes de trabalhar sozinhos.
Resumindo, um projeto refere-se a um conjunto de configurações e aplicativos destinados a criar um aplicativo da Web. Por outro lado, um aplicativo Django é parte de um projeto, que é autossuficiente (tem tudo o que precisa para funcionar) e seu objetivo é realizar uma operação específica.
Configurar um projeto Django
Nesta seção, você irá configurar um projeto Django. Para isso, você vai usar diferentes ferramentas como um ambiente virtual para organizar as dependências do Python e os scripts Django mais importantes. Django-admin e manage.py
ambiente virtual
Eu sempre recomendo trabalhar com ambientes virtuais ao criar aplicativos com Django. É a maneira mais eficiente de manter um conjunto específico de dependências. Mas seu principal objetivo é isolar os pacotes de desenvolvimento dos globais.
Então, vamos criar um ambiente virtual com python, o comando de formulário embutido.
Nota: Este método requer Python 3.6 ou versões mais recentes para funcionar.
python -m venv .venv
Este comando usa o comando python -m ou python –mod. Fundamentalmente, ele executa um módulo ou biblioteca, como um script. De acordo com o significado deste comando, venv é a biblioteca que estamos executando e .venv refere-se ao nome do ambiente virtual que queremos criar.
Portanto, em linguagem simples, esse comando significa.
Ei, Python, execute como um script a biblioteca integrada venv e crie um nome virtualenv .venv
Agora é hora de ativar o ambiente virtual que acabamos de criar, com o seguinte comando.
source .venv/bin/activate
Para afirmar que você não tem nenhum pacote instalado no novo venv, execute.
pip freeze
Se você ativou o ambiente virtual corretamente, não obterá nenhuma saída. Isso porque ainda não instalamos nada.
Vamos entrar no Django
Para criar nosso aplicativo encurtador de URL, vamos começar instalando o pacote Django. O Django é um pacote de terceiros, portanto, precisamos instalá-lo com o Pip (Pip Installs Packages).
$ pip install django
Collecting django
Downloading Django-3.2.1-py3-none-any.whl (7.9 MB)
|████████████████████████████████| 7.9 MB 344 kB/s
Collecting asgiref<4,>=3.3.2
Using cached asgiref-3.3.4-py3-none-any.whl (22 kB)
Collecting sqlparse>=0.2.2
Using cached sqlparse-0.4.1-py3-none-any.whl (42 kB)
Collecting pytz
Using cached pytz-2021.1-py2.py3-none-any.whl (510 kB)
Installing collected packages: asgiref, sqlparse, pytz, django
Successfully installed asgiref-3.3.4 django-3.2.1 pytz-2021.1 sqlparse-0.4.1
Nota: Lembre-se de que $ nada mais é do que o símbolo do shell.
Para verificar se a instalação ocorreu corretamente, verificamos novamente os pacotes instalados do nosso venv.
$ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1
Não se preocupe se as versões que você obtiver forem diferentes das minhas. Se o Django ainda estiver na versão 3.x você pode continuar sem nenhum problema.
Iniciando um projeto Django
Depois de instalar o Django, é hora de criar a estrutura do encurtador de URL do site. Você lembra o que é um projeto Django? Vamos criar um executando o seguinte comando.
django-admin startproject config
Explicando tudo sobre este comando, django-admin é um utilitário de linha de comando que executa todas as tarefas necessárias para criar um projeto Django. A parte “startproject” é o comando executado pelo utilitário Django-admin, e config é o nome do projeto que vamos criar.
É importante enfatizar que config pode ter o nome que você quiser. A razão pela qual uso config como o nome deste projeto é apenas por conveniência. É bom alternar entre projetos e ainda ter a mesma convenção de nomenclatura. Portanto, não tenha medo de usar outros nomes de projetos sempre que quiser.
Como você pode perceber agora você tem uma pasta config/ e dentro dela, existem muitos arquivos. Mais adiante veremos a estrutura de arquivos do projeto. Por enquanto, vamos entrar no diretório do projeto e rodar o servidor local.
cd config/
O arquivo mais importante que você usará é o script manage.py. Ele tem a mesma funcionalidade do django-admin, mas a principal vantagem de usá-lo é que permite gerenciar as configurações ao executar o projeto.
Agora vamos ver se tudo está funcionando corretamente.
python manage.py runserver
Criando o aplicativo encurtador de URL
É hora de criar o aplicativo principal do projeto. Você usará o arquivo manage.py para realizar esta tarefa.
python manage.py startapp urlshortener
Isso cria um aplicativo Django, com o nome urlshortener. Se você executar o árvore comando, você obterá algo assim.
.
├── config
│ ├── asgi.py
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── manage.py
└── urlshortener
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ └── __init__.py
├── models.py
├── tests.py
└── views.py
Vamos esclarecer os diferentes arquivos criados até este momento. “config” é o nome do nosso projeto e é assim chamado apenas por convenção. Dentro do config, você obtém o settings.py, é o arquivo onde você define todas as configurações do seu projeto. urls.py é a configuração geral das URLs dentro do projeto. Ele define os caminhos de URL de todos os aplicativos dentro do projeto.
Não se preocupe muito com os arquivos asgi.py e wsgi.py. Esses são arquivos que permitem configurar seu aplicativo na implantação.
O manage.py é o script python que permite executar todos os comandos disponíveis de Django-admin.
Dando uma olhada dentro do urlshortener que é o nome do aplicativo que você acabou de criar, você pode notar que existe uma pasta estranha chamada “migrations/” e alguns outros arquivos que são cruciais para a lógica de qualquer aplicativo.
apps.py é onde reside a configuração do aplicativo. Normalmente, você não mexe com isso, exceto que está fazendo coisas bastante avançadas.
admin.py é onde você registra seus modelos para torná-los visíveis dentro do painel de administração do Django.
models.py é o mais importante. Dentro deste módulo, você deve definir os modelos, que (vagamente dizendo) são a forma como os dados são armazenados. Você ouvirá mais sobre modelos mais tarde.
migrations/ é a pasta onde as migrations do Django são armazenadas. Faremos uma análise aprofundada mais adiante.
tests.py é o arquivo onde os testes são armazenados. Não abordaremos os testes neste tutorial.
views.py é o arquivo que armazena visualizações. Basicamente, define como o usuário irá interagir com todos os aspectos do seu app.
Instalando um aplicativo Django
Antes de continuar, abra o arquivo settings.py e modifique a variável INSTALLED_APPS adicionando o aplicativo urlshortener.
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# Custom apps
'urlshortener',
]
Este é um processo de rotina quando você cria um aplicativo. Portanto, toda vez que fizer isso, não esqueça de instalá-lo nas configurações do projeto.
Entendendo o padrão MVT
O padrão Model, View, Template é o padrão de projeto de software que os desenvolvedores Django usam para criar aplicações web.
É baseado em 3 conceitos principais. Model (dados), View (interação do usuário com os dados), Template (como os usuários veem os dados).
Models são classes Python, que definem todos os campos e comportamentos dos dados que você deseja armazenar. Normalmente, cada modelo se refere a uma tabela única no banco de dados
As visualizações, em sua expressão mais simples, são chamadas que recebem uma solicitação do usuário e geram uma resposta. Entre esse processo ocorre a lógica de negócios. Eu sei que “lógica de negócios” é um conceito bastante obscuro, então deixe-me explicar exatamente o que é. A lógica de negócios é a maneira como os dados são criados, armazenados e excluídos, só isso.
Finalmente, os modelos são documentos de texto (normalmente Html) que são mostrados aos usuários. Seu objetivo é apresentar os dados da forma mais limpa possível. Django incorpora uma mini-linguagem chamada Linguagem de modelo Django (DTL) que permite incorporar parte do poder do python em documentos de texto.
Criar o modelo Shortener
Uma vez que você tenha uma compreensão rápida do padrão MVT, vamos começar a criar o encurtador de URL do Django do zero.
Primeiramente, vamos definir o modelo encurtador dentro do arquivo models.py.
'''
Url shortener model
'''
from django.db import models
# Create your models here.
class Shortener(models.Model):
'''
Creates a short url based on the long one
created -> Hour and date a shortener was created
times_followed -> Times the shortened link has been followed
long_url -> The original link
short_url -> shortened link https://domain/(short_url)
'''
created = models.DateTimeField(auto_now_add=True)
times_followed = models.PositiveIntegerField(default=0)
long_url = models.URLField()
short_url = models.CharField(max_length=15, unique=True, blank=True)
class Meta:
ordering = ["-created"]
def __str__(self):
return f'{self.long_url} to {self.short_url}'
Eu sei. É uma turma bem grande, com muita coisa estranha acontecendo, mas não se desespere. Eu vou passo a passo em cada coisa importante.
Explicação do modelo
Em primeiro lugar, importamos o módulo models. Este módulo contém todas as funcionalidades que precisamos para criar um modelo Django.
Dando uma olhada no modelo “Shortener”, a primeira coisa a notar é que ele estende models.Model. Na verdade, qualquer modelo em qualquer aplicativo Django deve ser uma subclasse do modelos.Modelo classe.
Em seguida, definimos todos os campos que o modelo terá no banco de dados. O campo “criado” é a data e hora em que o link encurtado é criado, portanto usamos DateTimeField para criar esse tipo de funcionalidade. Usamos o argumento auto_now_add=True porque queremos que o campo seja alterado apenas quando a instância for criada.
O segundo campo times_followed refere-se às vezes que o URL encurtado foi usado. É um PositiveIntegerField e especificamos um padrão de zero. Isso significa que toda vez que uma instância criar o campo times_followed, o Django preencherá esse campo com 0.
Por outro lado, long_url refere-se à URL que o usuário insere. É um URLField, pois queremos que o usuário insira apenas caracteres do formulário: http://seusite.com.
O último campo é short_url e possui detalhes interessantes. Especificamos que só pode ter 15 caracteres, deve ser único, o que significa que não pode haver elementos repetidos nesse campo. Finalmente, indicamos que pode ser deixado em branco, o que significa que, ao trabalhar com formulários, o usuário não precisará escrever seu próprio código abreviado.
A classe interna Meta, nos diz como a classe deve se comportar, e definimos que a ordenação (chamando Shortener.objects.all()) dos objetos encurtadores será discriminada pelos mais recentes.
O método __str__ informa como o modelo deve ser impresso. Portanto, se tivermos um objeto com long_url = “https://etechpt.com.com/” e a parte abreviada “123456”, e o imprimirmos.
https://etechpt.com.com/ to 123456
Agora é hora de procurar uma maneira de salvar o link curto de maneira aleatória.
Criando funcionalidade de encurtamento
Vamos criar 2 funções personalizadas. O primeiro gerará um código aleatório e o segundo impedirá a obtenção de códigos aleatórios repetidos do modelo Shortener. Para fazer isso, crie um arquivo utils.py dentro do app “urlshortener”.
touch utils.py
Dentro deste arquivo, vamos usar a função de escolha do módulo interno aleatório. Isso facilita a tarefa de escolher caracteres aleatórios para criar o código.
'''
Utilities for Shortener
'''
from django.conf import settings
from random import choice
from string import ascii_letters, digits
# Try to get the value from the settings module
SIZE = getattr(settings, "MAXIMUM_URL_CHARS", 7)
AVAIABLE_CHARS = ascii_letters + digits
def create_random_code(chars=AVAIABLE_CHARS):
"""
Creates a random string with the predetermined size
"""
return "".join(
[choice(chars) for _ in range(SIZE)]
)
Como você pode ver, esta função retorna uma string aleatória do comprimento especificado no arquivo de configurações ou 7 por padrão. Você está usando a função getattr para obter uma variável do módulo de configurações, mas sem lançar um erro se a variável não for especificada.
Vamos fazer algumas contas. Se tivermos 7 lugares onde pode haver até 62 personagens disponíveis para cada lugar, o possível permutações são:
Portanto, com base nesses cálculos rápidos, a parte abreviada pode ser preenchida com até 2,5 trilhões de códigos diferentes. Portanto, podemos esquecer de sair de URLs abreviados aleatórios.
Embora possa existir tanta permutação, há uma pequena probabilidade de obter partes encurtadas repetidas. Isso é um problema, pois configuramos o campo shorted_url para ser exclusivo. É por isso que a função a seguir é tão útil.
def create_shortened_url(model_instance):
random_code = create_random_code()
# Gets the model class
model_class = model_instance.__class__
if model_class.objects.filter(short_url=random_code).exists():
# Run the function again
return create_shortened_url(model_instance)
return random_code
Vamos ver o que está acontecendo aqui. A função recebe como argumento uma instância do modelo “Encurtador”. Primeiro, a função gera um código aleatório usando o create_random_code. Em seguida, ele pega a classe do modelo e verifica se existe algum outro objeto que tenha o mesmo short_url. Se funcionar ele roda sozinho mais uma vez, mas se estiver tudo bem ele retorna o random_code.
Mais tarde, você interagirá com o shell, a fim de dar uma olhada nesta função de perto.
Depois de criar a função de utilidade, vamos usá-la para criar códigos aleatórios no modelo de encurtador.
Modificando o método de salvamento
Ao final da classe “Shortener”, você modificará o método de salvamento do modelo. O método save é chamado toda vez que um objeto é salvo no banco de dados, então veremos como utilizá-lo aqui.
# Import the function used to create random codes
from .utils import create_shortened_url
# At the end of the Shortener model
def save(self, *args, **kwargs):
# If the short url wasn't specified
if not self.short_url:
# We pass the model instance that is being saved
self.short_url = create_shortened_url(self)
super().save(*args, **kwargs)
O método save está sendo substituído, o que significa que você está introduzindo uma nova funcionalidade em um método pai pré-existente. Ele basicamente diz ao Django que cada vez que um objeto “Shortener” é salvo e o short_url não é especificado, ele deve ser preenchido com um código aleatório.
Executando migrações
Agora é hora de fazer e executar as migrações do modelo Shortener. Para fazer isso, execute os seguintes comandos na pasta raiz do projeto.
$ python manage.py makemigrations
Migrations for 'urlshortener':
urlshortener/migrations/0001_initial.py
- Create model Shortener
$ python manage.py migrate
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions, urlshortener
Running migrations:
......
# Apply the URL shortener migrations
Applying urlshortener.0001_initial... OK
Por enquanto, você não precisa se preocupar com o que são as migrações. Apenas tenha em mente que ao executar esses dois comandos o Django cria um banco de dados db.sqlite arquivo, com base nos modelos que você definiu.
Vamos criar alguns objetos com o shell do Django.
$ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://etechpt.com.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://etechpt.com.com' >>> print(s) https://etechpt.com.com to kdWFVIc
É assim que todos os objetos encurtadores funcionarão.
Escrevendo visualizações
Como eu disse antes, uma visão é uma função simples que recebe uma solicitação e retorna uma resposta. Então, vamos ver como criar uma visão de mundo hello.
Modelo básico de resposta
Dentro do arquivo “urlshortener/views.py” crie uma função home_view. aa
'''
Shortener views
'''
from django.shortcuts import render, get_object_or_404 # We will use it later
from django.http import HttpResponse
# Create your views here.
def home_view(request):
return HttpResponse("Hello world")
Ele retorna uma mensagem simples “Hello world”. Mais tarde, você verá como fica no navegador. Agora crie um “urls.py”, nele ficarão todos os padrões de URL do app.
toque urls.py
Adicione o seguinte código.
'''
Urls for shortener app urlshortener/urls.py
'''
from django.urls import path
# Import the home view
from .views import home_view
appname = "shortener"
urlpatterns = [
# Home view
path("", home_view, name="home")
]
A variável appname declara (como o próprio nome sugere) o namespace do aplicativo urlshortener.
Explicando rapidamente que estamos importando o função de caminho, que retorna um elemento para incluir nos urlpatterns do aplicativo. O atributo name é o namespace do caminho, que pode ser chamado dentro de templates se necessário.
Agora, vamos modificar as URLs gerais do projeto.
# config/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
# Shortener Urls
path('', include('urlshortener.urls'))
]
Agora vamos executar o servidor novamente.
python manage.py runserver
Se você executar o servidor, receberá uma mensagem simples “Hello world”. Isso ocorre porque você está incluindo os urlpatterns do aplicativo encurtador de URL no projeto geral.
Isto é só um ponto de partida. Agora é hora de criar um formulário para permitir que o usuário crie URLs abreviadas por conta própria.
Criando formulários
Em Django, um Formato é uma classe simples que permite obter entrada do usuário.
Você vai criar um arquivo forms.py. É uma convenção armazenar todos os formulários do aplicativo nesse arquivo.
cd urlshortener/ touch forms.py
Dentro desse arquivo você vai criar uma classe “ShortenerForm” que estende de “ModelForm”.
'''
Shortener Forms urlshortener/forms.py
'''
from django import forms
from .models import Shortener
class ShortenerForm(forms.ModelForm):
long_url = forms.URLField(widget=forms.URLInput(
attrs={"class": "form-control form-control-lg", "placeholder": "Your URL to shorten"}))
class Meta:
model = Shortener
fields = ('long_url',)
É um formulário de modelo, pois seu objetivo é criar um objeto de modelo a partir da entrada do usuário. Também usamos o argumento widget, que nos permite especificar o atributo “class” (classe em CSS, não em python). Isso ocorre porque vamos estilizar o aplicativo com bootstrap posteriormente.
Finalizando as visualizações
Depois de construir os formulários é hora de criar a lógica de negócios final do aplicativo.
Navegue até o arquivo views.py dentro do aplicativo encurtador e modifique a visualização home_view. Você pode conferir o repositório Github neste momento para ter uma ideia de como é a estrutura do projeto.
Existem duas visualizações para o aplicativo encurtador de URL:
Vamos começar com a visualização inicial, que é a mais complexa. Você precisará importar o modelo e o formulário do Shortener. Você ainda está usando uma função, pois quero que você entenda todo o fluxo de dados da exibição. Além disso, você usará o caminho para um modelo (que ainda não foi criado).
Vista inicial
'''
Shortener views
'''
from django.shortcuts import render # We will use it later
from django.http import HttpResponse, Http404, HttpResponseRedirect
# Model
from .models import Shortener
# Custom form
from .forms import ShortenerForm
# Create your views here.
def home_view(request):
template="urlshortener/home.html"
context = {}
# Empty form
context['form'] = ShortenerForm()
if request.method == 'GET':
return render(request, template, context)
elif request.method == 'POST':
used_form = ShortenerForm(request.POST)
if used_form.is_valid():
shortened_object = used_form.save()
new_url = request.build_absolute_uri('/') + shortened_object.short_url
long_url = shortened_object.long_url
context['new_url'] = new_url
context['long_url'] = long_url
return render(request, template, context)
context['errors'] = used_form.errors
return render(request, template, context)
A exibição é baseada em dois condicionais:
Uma maneira complicada de obter a URL completa do site dinamicamente é usando o método de objeto de solicitação build_absolute_uri .
>>> print(request.build_absolute_uri('/'))
'https://localhost:8080/'
Como uma forma segura de processar uma solicitação errada (o usuário não digitou uma URL válida), obtemos os erros do formulário, os passamos como contexto e renderizamos o modelo normalmente. Posteriormente, você verá como implementar a exibição de erro no modelo.
Redirecionar visualização
O redirect_url_view , é um pouco mais simples. É uma visão detalhada, o que significa que a visão só funciona com um objeto.
Esta função recebe como parâmetros a requisição do usuário e a shorted_part da URL. Não é necessário afirmar o tipo de solicitação que estamos recebendo, pois não estamos trabalhando com formulários nesta visão.
def redirect_url_view(request, shortened_part):
try:
shortener = Shortener.objects.get(short_url=shortened_part)
shortener.times_followed += 1
shortener.save()
return HttpResponseRedirect(shortener.long_url)
except:
raise Http404('Sorry this link is broken :(')
Protegemos a exibição com uma instrução try/except, caso a parte abreviada não seja encontrada no banco de dados. Se o objeto for encontrado, ele adiciona 1 ao campo times_followed e redireciona com a função HttpResponseRedirect para a URL do site correspondente ao código aleatório.
Atualizando URLs
Depois de criar as duas exibições do aplicativo, é hora de criar os padrões de URL finais incluindo o caminho para o redirect_url_view.
Como sempre, você começa importando as visualizações e, em seguida, cria uma função de caminho e passa como argumentos:
- A rota de URL
- A vista aponta para o caminho
- O nome do caminho
'''
Urls for shortener app urlshortener/urls.py
'''
from django.urls import path
# Import the home view
from .views import home_view, redirect_url_view
appname = "shortener"
urlpatterns = [
# Home view
path('', home_view, name="home"),
path('<str:shortened_part>', redirect_url_view, name="redirect"),
]
Com essa configuração de URL, o roteamento do aplicativo fica assim.
- localhost:8000/: visualização inicial
- localhost:8000/URL-code: Redirecionamento para o URL longo
Criando modelos
Você está quase lá. A única coisa que separa você de ter criado este aplicativo é a interface do usuário. Para isso, usamos templates Django.
Os modelos são usados para renderizar uma interface limpa para o usuário do aplicativo. Esses arquivos são criados dentro do aplicativo em uma estrutura de pasta dupla no formato: “templates/appname”
# urlshortener directory mkdir -p templates/urlshortener/
Nota: A estrutura de pasta dupla e a linguagem Django Template estão além do escopo deste tutorial, mas você pode ler sobre eles no documentação oficial.
modelo básico
Django permite herança de template. Isso significa que podemos ter um modelo base e estendê-lo com o objetivo de seguir o princípio DRY (Don’t repeat yourself).
cd templates/urlshortener touch base.html
O arquivo base.html é uma convenção e significa que todos os outros modelos no aplicativo devem ser uma extensão deste.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Django Url shortener</title>
<link
href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
rel="stylesheet"
integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0"
crossorigin="anonymous"
/>
<link
rel="stylesheet"
href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css"
integrity="sha512-iBBXm8fW90+nuLcSKlbmrPcLa0OT92xO1BIsZ+ywDWZCvqsWgccV3gFoRBv0z+8dLJgyAHIhR35VZc2oM/gI1w=="
crossorigin="anonymous"
/>
</head>
<body>
{% block body %}
{% endblock body %}
<script
src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"
integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8"
crossorigin="anonymous"
></script>
</body>
</html>
Vamos usar o bootstrap CDN, para fazer uma interface rápida e bonita sem precisar de arquivos CSS ou javascript.
Se você deseja aprender profundamente sobre tags DTL, pode fazê-lo com o documentos oficiais.
modelo inicial
O modelo inicial, inerência do arquivo base.html. Isso significa que este modelo inclui todo o HTML do arquivo pai.
{% extends 'urlshortener/base.html' %}
{% block body %}
<div class="container">
<div class="card mt-5">
<div class="card-header text-center py-3">
<h1>URL Shortner Application <i class="fas fa-link px-2"></i></h1>
</div>
<div class="px-3 py-4">
<form action="" method="POST">
{% csrf_token %}
<div class="row g-1">
<div class="col-10">{{form.long_url}}</div>
<div class="col-2">
<button class="btn btn-success btn-lg w-100" type="submit">
Shorten
</button>
</div>
</div>
</form>
</div>
</div>
{% if errors %}
<div class="alert alert-danger mt-4" role="alert">
<p>{{errors}}</p>
</div>
{% endif %}
{% if new_url %}
<div class="mx-auto text-center mt-5">
<h2 class="text-danger">Your shortened Url</h2>
<p>You can copy the Link below and share it with your friends</p>
<p class="">{{new_url}}</p>
<p><span class="text-danger">Previous URL:</span> {{long_url}}</p>
</div>
{% endif %}
</div>
{% endblock body %}
Vou explicar rapidamente o fluxo de dados deste modelo:
- O formulário do Encurtador é exibido. Dentro de símbolo crsf está definido (Motivos de segurança) e apenas o campo de URL longo do formulário é mostrado. Lembre-se que este campo possui a classe CSS, “form-control form-control-lg”, pois definimos isso no formulário.
- Se algum erro for encontrado, mostre-o
- Se a operação POST for bem-sucedida, a nova URL será exibida.
Aplicação final
Parabéns! 🎉. Você construiu um aplicativo encurtador de URL funcional completo com Django.
Aqui estão algumas capturas de tela de como o aplicativo se parece.
Obtenha apenas:
URL de encurtamento de erro:
URL encurtado com sucesso:
URL redirecionado:
O que você acha de expor uma demonstração deste aplicativo encurtador de URL para alguém? Veja como expor um aplicativo Django Demo para a internet.
Desafio 🔥
Se você se sente confortável com suas habilidades em Django, por que não praticar com um desafio?
Clone o código desta aplicação e crie um sistema de autenticação, onde apenas usuários cadastrados podem encurtar suas URLs.
Quando terminar, envie um pull request e me envie um ping Twitter para mostrar suas conquistas.
Empacotando
Você chegou ao final deste tutorial. Acredite ou não, você acabou de revisar todos os aspectos principais da criação de um projeto Django. Espero que você tenha achado extremamente útil.
Neste tutorial você:
- Aprendeu sobre o fluxo de trabalho de criação de um aplicativo Django.
- Construiu um projeto de currículo
- Compreendeu as diferenças e a estrutura dos projetos Django e dos aplicativos Django.
- Descobriu o padrão MVT.
- Visualizações básicas da função criada
- Usou o Django ORM (Object Relational Mapper) para criar modelos simples
Isso é tudo, há muito o que cobrir com o estrutura da web Djangoentão mantenha contato para mais tutoriais incríveis.