Olá e bem-vindos a outro Django
para todos passarem.
Então você provavelmente está neste ponto
trabalhando em sua tarefa de automóveis.
Esta é a nossa primeira
atribuição real de criação, leitura, atualização e exclusão.
Muito do que é esta tarefa,
é olhar para o código
que eu te dei em DJ4E Samples e puxá-lo para dentro.
Não clone o repositório para esta atribuição.
O DJ4E Samples é um monstro.
Ele tem todos os tipos de coisas
nele, é muito complexo e você não quer.
Você quer começar com um aplicativo agradável e limpo.
Sua tarefa anterior era fazer
um aplicativo muito pequeno para baixo,
nós vamos estender esse aplicativo.
É por isso que você já tem esses
projetos DJ4E em seu lugar onde quer que ele esteja.
Então o que isso é,
é essa atribuição é evoluir
isso usando o código de exemplo.
Mas o que eu realmente vou
fazer é percorrer
o código de exemplo porque há
novos conceitos neste código de exemplo.
Então isso é mais uma palestra sobre
o código de exemplo do que exatamente como fazer a tarefa.
Mas, importante, você precisa
entender cada linha porque literalmente,
cada programa que vamos escrever para
as próximas n semanas é uma variação neste CRUD.
Então essas visualizações padrão,
o get 404,
todas essas coisas são realmente uma base em muitas coisas.
O que vamos encontrar é a
maneira certa de escrever este código,
como tudo no Django,
é realmente pequeno e sucinto.
Então vamos dar uma olhada no código.
Bem, vamos em frente e rodar o código.
Vá para automóveis, e você tem que fazer login.
Então a idéia disso é que existem duas tabelas.
Há uma tabela de marcas.
Então eu vou adicionar um make
e então eu vou adicionar um auto,
e a coisa legal sobre isso é que este é Neon
1, quilometragem 1.234, SakalCard.
Então eu tenho este menu suspenso legal.
Então, há um monte de formulários acontecendo aqui,
há drop-downs, há muitos
para um relacionamento acontecendo.
Então eu tenho essa lista e eu posso atualizá-la e excluí-la.
Então é aí que está o nosso CRUD completo.
Então podemos adicionar marcas,
ver marcas, adicionar automóveis, etc.
Então essa é toda a amostra.
Então é muito perto do que é que você tem que escrever,
é só não ir agarrar e todas essas coisas.
Então vamos começar por dar uma olhada.
Então eu estou aqui sentado no meu DJ4E Samples.
Se você olhar, você vê todos os
meus vários aplicativos em um projeto.
Então nós temos os automóveis,
mas eu realmente quero começar com o código de autenticação,
se eu voltar aqui para amostras,
deixe-me sair, o código que me permite fazer login.
Então, se eu for direto para automóveis para ver se desconectei.
Você vai notar que o que ele faz
quando eu ir direto para automóveis,
é ele me encaminha para login,
e depois com o próximo para voltar para auto.
Assim, esta vista em autos,
o /autos protegeu-se com mixagem de login.
Mais tarde vamos fazer login,
seu login não vai ficar assim,
mas este é o que eu tenho em amostras.
Você não tem que torná-lo bonito ainda,
uma próxima missão vai fazer tudo bonito.
Então agora estamos em automóveis e estamos logados.
Seu aplicativo tem que ter mais algumas coisas aqui,
mas eu estou mais interessado em
mostrar-lhe realmente a essência
dos pontos de vista neste carro.
Vamos apenas rever brevemente sobre como funciona o login automático.
Então, se eu olhar para dj4e-samples/settings.py,
você precisa ter essa autenticação conectada.
Então isso é basicamente um monte de código, algumas visualizações,
etc, que vem do Django,
e que tem estado lá o tempo todo
quando você fez seu projeto inicial.
Claro, então em algum lugar aqui,
nós temos que ter os automóveis, onde quer que os automóveis estejam.
Sim, configuração do aplicativo de autos,
você tem que puxar o aplicativo de automóveis.
Se eu olhar para dj4e-samples/urls.py,
então eu posso encontrar automóveis aqui,
e precisa haver alguma linha que basicamente diga,
“No nível superior,
tudo abaixo de autos é delegado
ao arquivo URLs em autos.py.
Mas também há as contas.”
Então, se você se lembra,
este é um monte de views que vêm do Django para nós,
ele é pré-instalado para nós.
A coisa que temos que fazer é
fornecer um modelo
com o nome registration.html.
Então eu acho que eu tenho isso em casa/templates/registration/.
Sim, eu sei. Então, na verdade, eu tenho dois logins.
Eu tenho um realmente simples como login.html.
Este é o que eu recomendo que você comece.
Mais tarde, usaremos o login social. Isto é muito simples.
É uma página de login que usa a capacidade de formulários do Django.
Se formados erros,
isso significa que há um erro de validação.
Ele voltou e reexibiu
esta página e mostrou um erro.
Em seguida, fazemos um formulário de postagem simples com um URL
que é uma pesquisa inversa para uma vista com um nome de login.
Em seguida, colocamos o token CSRF e, em seguida, tomamos o formulário,
e eu estou fazendo isso com tags de parágrafo.
Então esse é um login simples,
esse não é o real que estamos mostrando.
Em seguida, o próximo é um valor oculto que você tem
que passar para que quando você realmente entrar com sucesso,
ele saiba voltar para automóveis.
Quando tudo estiver pronto, ele volta
aqui após o login ter sido feito.
Então esse registro/login,
você pode colocar isso em qualquer um dos seus aplicativos,
mas você quer nomeá-lo registration/login.html.
Então, se eu der uma olhada bem rápido
e eu entrar em casa/modelos,
estes são todos os modelos.
Quando eu faço um ls, você verá que eu tenho
uma casa/templates/casa e uma casa/modelos/registro.
Você pode ter mais de uma pasta aqui.
Se eu olhar para o que está no registro,
você vê que eu tenho este login simples e, mais tarde,
o login mais complexo que nos dará
os recursos de login do GitHub.
Então o que isso significa é login use social.
O ponto é abaixo desses modelos,
você não precisa ter apenas uma subpasta,
você pode ter mais de uma subpasta.
Então, essa é a configuração necessária para torná-lo de modo
que quando dizemos aos nossos pontos de vista para adicionar o mixin de login,
que veremos em apenas um segundo.
Dizemos aos nossos pontos de vista no login para usar o mixin de login,
então ele sabe onde obter o modelo.
Então isso é apenas uma parte e
suas instruções lhe dizem como fazer isso.
Então, qualquer aplicativo que você está indo para
construir ou qualquer projeto que você está indo para construir,
você tem que colocá-los em configurações py,
urls.py, e então fazer o modelo.
Então você tem que começar a usar
mixin de login e, em seguida, tudo apenas
magicamente começa a se juntar.
Então vamos dar uma olhada no aplicativo de automóveis real.
Vamos olhar para algumas coisas diferentes
aqui, autos/urls.
Eu vou fazer uma guia multi-terminal, para
que eu possa alternar de volta entre arquivos muito rápido.
Você provavelmente tem um editor de texto melhor do que eu.
Então eu tenho URLs,
eu vou dar uma olhada no autos/views.py.
Então eu vou olhar para autos/model.py.
Então eu vou olhar para autos/forms.py.
Então vamos trabalhar através desses quatro arquivos,
URLs, visualizações, modelos, formulários.
Provavelmente vamos fazer modelos primeiro.
Então isso é bem simples.
Vamos fazer uma classe de objeto Make.
Vai ter um campo de caracteres
com alguns validadores nele.
Brincamos com isso com formulários.
Você pode colocar validadores em modelos.
Nós já vimos validadores anteriormente em forma,
mas há um validador que basicamente diz,
nós não vamos aceitar dados entrando
nesta tabela de banco de dados a menos que
haja pelo menos dois caracteres.
Este _str_, você tem feito isso por um tempo.
Isso é basicamente se você pegar
um objeto modelo em uma marca real e
imprimi-lo, ele diz qual dos campos,
neste caso, há apenas um campo.
Então isso só diz que quando estamos convertendo
um objeto modelo em uma string,
nós começamos a decidir como isso parece.
Então temos um automóvel e ele tem
um apelido com um MinLengthValidator, max_length de 200,
e quilometragem, que tem um campo inteiro, um comentário,
que é um campo de 300 caracteres,
e então uma chave estrangeira também.
Isso como um relacionamento um-para-muitos ou muitos-para-um,
não um muitos-para-muitos, apenas uma chave estrangeira para Make.
Então vamos on_delete
CASCADE, o que realmente significa que se você excluir um Make,
então as entradas automáticas correspondentes
serão automaticamente excluídas.
Então este é um modelo bem simples,
na verdade muito, muito simples.
Mais uma vez, estamos sempre definindo
este _str_ (self) para que saibamos que se você está
apenas mostrando como na
interface de administração ou se você está apenas
imprimindo ou apenas
convertendo o próprio modelo em uma string,
o campo entre esses campos que
é suposto ser usado é o campo de alcunha,
apenas para mostrar aos usuários finais.
Então esse é o arquivo dos modelos.
Vamos ver o arquivo de formulários a seguir.
Então o arquivo de formulário é interessante,
porque vimos formulários que
são apenas formulários por si mesmos,
mas este é um tipo especial de
forma e então é um ModelForm.
Nisso, nós normalmente nos outros modelos,
tínhamos todos esses campos,
e nós os colocamos e
parecia muito com um arquivo modelo onde
temos um campo de caracteres, PositiveIntegerField.
Mas o que estamos basicamente a dizer é, sabes que mais?
Vamos fazer um formulário aqui.
Realmente, tudo o que queremos fazer é pegar
todos os campos
do modelo Make e torná-los campos de formulário.
Então, uma forma e um modelo são duas coisas diferentes.
Um formulário é algo que vai
entre a exibição e o modelo,
e como você verá,
ele também vai para baixo para os modelos automaticamente,
então isso é apenas como fazer todos os campos.
Vamos criar um formulário porque
os objetos de formulário não precisam ser associados a modelos.
Mas neste caso, vamos
derivar um objeto de forma de um modelo.
Então, em vez de estender forma, estamos estendendo ModelForm.
Então isso é um ModelForm deve ter,
e isso é apenas alguns dados que dizem que o modelo que
vamos extrair todos os nossos campos é o modelo Make,
e ele só tem uma coisa que é um nome.
É isso. Então isso é gerar automaticamente
um formulário que se
nós mudamos e adicionamos outro campo aqui,
então este formulário make teria automaticamente um campo.
Você pode dar a ele uma lista de campos,
_ _ todos _ _ é
como um sinal para dizer, “Apenas me dê todos eles.”
Agora pode haver algumas
coisas internas, como criado e
atualizado em ou algo que você não deseja usar.
Então isso é uma forma, lembre-se de como os formulários funcionam.
Nós cobrimos isso antes. Vamos dar uma olhada nos nossos URLs.
Agora, muito disso parece
muito parecido com as coisas que fizemos.
Basicamente temos uma tabela principal,
que é a nossa tabela de automóveis,
e a nossa tabela de pesquisa, que é a nossa tabela de marcas.
Então temos três coisas,
há a lista principal,
que é listar todos os automóveis.
Há o principal modo de exibição de lista Make,
que é listar todas as marcas.
Então podemos fazer
uma nova que não tem uma chave primária,
porque parte das idéias que
criam é fazer uma coisa nova,
que vai gerar uma chave primária.
Então vamos ter uma atualização e uma exclusão.
Então temos uma leitura, criação, atualização, exclusão.
Então não é exatamente crédito,
mas você vê todas essas quatro coisas.
Então, temos visualizações,
e nomeamos essas visualizações para que possamos
referenciá-las em nossas
próprias visualizações e em nosso modelo para
que possamos fazer links entre elas.
Então estes são bastante
simples e não tão diferentes.
Então a diversão começa a acontecer quando estamos no views.py.
Então, faça login mixin,
se você se lembrar do autor do z passo a passo,
basta adicionar isso a uma vista e ele
basicamente diz que você não pode chegar
a esta visualização a menos que você esteja conectado
e se você não estiver logado,
ele irá bater no
arquivo login.html e, em seguida, voltar depois que você estiver feito.
Então LoginRequiredMixin é tudo o que precisamos fazer.
Se você vai para o autor z amostra,
você vai ver como eu fiz isso à mão.
Você não quer fazer isso à mão,
você só chama login mixin.
Agora, então esta visão principal é uma exibição de lista,
e então vamos dar
uma olhada em como isso vai se parecer.
Este é o modo de exibição de lista.
Então vamos fazer quantas auditorias temos,
vamos percorrer essa lista,
vamos recuperar todas as auditorias do banco de dados.
Em seguida, vamos ter um adicionar o link automático,
em seguida, uma visão que
faz o link com uma contagem de quantas marcas existem e adicionar um make.
Então deixe-me também, em seguida, ir para modelos de
automóveis, automóveis novamente, e lista automática.
Então este é o modelo que faz isso.
Então, há algumas coisas que temos,
nós temos uma lista automática.
Agora, os nomes destes não são forçados a vocês,
mas há convenções que acabam em um momento,
vamos parecer realmente úteis.
Então vamos conseguir uma lista automática.
Se voltarmos aos nossos pontos de vista,
vemos que dizemos,
obter todos os objetos da tabela automática,
todos os objetos de classe automática recuperá-los todos,
passando-os para o contexto como auto_list.
Agora nós também queremos ser capazes de
mostrar essa pequena contagem, este é o número dois,
então nós vamos perguntar,
ir em frente para os objetos make
todos, mas não me dê uma lista deles,
contá-los e me dê um número.
Então fazer contagem está preso lá e você vai
ver se pode contar é maior que zero.
Podemos mostrar o anúncio e o botão automático,
e também em algum lugar mostra o make count,
ver todas as marcas, adicionar um make,
e o make count vem aqui.
Então isso é outra coisa que colocamos.
A lista automática que vamos passar e que
variável de iteração de auto vai
passar por cada uma das coisas separadas,
e apelido, make, etc,
isso é direto para fora do arquivo models.py.
Há as quatro coisas que todo carro tem,
e estamos apenas imprimindo tudo isso.
Você também obtém a chave primária,
e então nós vamos fazer um URL de atualização,
e esse URL é para autos: auto_update.
Então, se você olhar em urls.py,
vemos esta atualização automática olha para cima,
isso nos dá um caminho para a exibição,
mas esse caminho específico precisa de
um parâmetro
que é uma chave primária, e isso significa que esta tag de modelo de URL,
autos tem
que ter o auto.id. através dos modelos,
você tem um, e você faz um auto_create,
isso é bastante direto.
Mas uma das regras é, você tem que ter
pelo menos um make antes que você possa fazer um auto,
porque se você lembrar,
adicionar um auto tem que ter
esta lista suspensa preenchível e
que está sendo puxado da tabela make,
e isso é basicamente a maneira de contornar isso.
Essa é a vista principal.
Aqui vamos nós, atualize.
Essa é a vista dos automóveis, e se fizermos a vista,
faremos a mesma coisa.
Se olharmos para a lista de marcas,
estamos fazendo a mesma coisa básica,
ver todas as marcas,
e agora temos atualização e exclusão.
Assim você não precisa contar.
Nós só queremos pegar todos os objetos,
queremos colocá-lo em um contexto sob lista make,
e então fazemos lista no HTML,
e isso é ainda mais simples.
É só passar pela lista de marcas
, vem através do contexto.
Se não houver nenhum, nós não imprimimos isso,
e então nós colocamos para fora o nome dele,
e então nós temos uma atualização e um botão de exclusão
que vai para a atualização e exclusão,
e claro, se você olhar em urls.py,
esses também a atualização e exclusão
têm requisitos de chave primária,
e assim você tem uma chave primária
que você tem que passar aqui
para tornar esse URL o URL apropriado,
e então apenas alguns links para
voltar para as várias coisas para que
possamos voltar para automóveis,
ver marcas, adicionar um novo make.
Agora, cancele todas essas coisas.
Então esse é o views.py
para listar os automóveis e as marcas.
Agora, queremos fazer com que o make create view.
Então, se dermos uma olhada no make create view,
que é adicionar um make.
Isso vai criar este formulário.
Eu posso fazer isso maior aqui.
Pode criar esta forma,
onde vamos colocar uma coisa chamada Chevy.
Então precisamos de uma maneira de fazer esta forma.
Vamos fazer um login necessário,
não vamos deixar que as pessoas façam isso.
Nós vamos ter algumas variáveis que são classe ampla,
como o modelo que queremos usar,
e success_url é depois de ter feito isso direito.
Agora, se você apenas
submetê-lo e ele reclamar, ele não faz isso.
Mas uma vez que você fez certo, para
onde você quer ir depois?
Chevy, para onde quer ir depois?
Esta é a função do controlador.
Eu quero voltar para a lista automática,
e assim o success_url é ir
para autos:all que em urls.py é esta visão principal.
Esse é o nome da visão principal,
e então se formos aqui,
qual modelo usar e qual success_url.
Se fizermos uma solicitação get,
vamos construir um formulário para
o make que vem de forma make,
mas realmente vem do modelo make,
que é apenas um campo string.
Tão simples quanto isso. Vamos reutilizar isto.
Só estamos dizendo, vamos fazer uma forma
que puxe daqui.
Temos que passar um formulário,
porque os modelos não podem ser usados para criar esta tela.
Essa tela vem de um formulário.
Está bem. Se dermos uma olhada no modelo,
se olharmos para o make criar
modelo ou fazer formulário.
Então esse é o modelo que vamos usar para criar forma.
Vamos precisar de form_as_table.
Então é assim que fizemos formulários.
Coloque o token CSRF,
você faz uma tabela,
que pode ser como parágrafos ou como tabelas.
Mas seja o que for, você precisa deste objeto de forma.
Então você precisa passar o objeto de formulário em.
Então aqui estamos nós, vamos fazer um formulário
e, em seguida, vamos para o objeto formulário em,
e então nós vamos renderizar para autof.template
autos.makeform html.
Então vamos devolver isso para o “get”.
Então, quando apertamos
o botão o botão enviar, Adicionar um make,
apertamos o botão enviar,
ele está entrando no post
porque fizemos um post formulário, entra.
Não faça isso. Isso é terrível.
Odeio quando vi faz isso.
Mas aqui vamos nós, estamos de volta.
- Sim. Então post vem em,
Request.post tem todos os pares de valor de chave
que são esses pares chave-valor, conforme definido pelo formulário.
Então nós dizemos vamos fazer um formulário com
os dados iniciais vindo do post pedido.
Dado que o formulário o gerou,
ele sabe quais são os nomes desses campos,
e isso é algo que se esconde atrás de como os formulários funcionam.
Mas também verifica se os dados do formulário são válidos e
isso significa que somos todas essas regras validadoras seguidas.
Se as regras do validador não forem seguidas,
se o formulário não for válido,
vamos apenas enviá-lo de volta.
Então este código aqui,
este formulário não é um código válido.
Se eu colocar em uma única letra A e apertar “Submeter”,
ele vai voltar e rerenderizar
o formulário e todas as coisas de erros,
tudo isso é tudo tratado por este código de formulário,
este código de formulário Django descobre o que está errado.
Só um pouquinho para que eu possa
voltar mais rápido. Lá vamos nós.
Ele descobre o que está errado com ele,
faz uma mensagem de erro,
a mensagem de erro veio do models.py aqui.
Não, aqui mesmo.
Em seguida, passou por forms.py porque é
uma forma em última análise que herdamos do
formulário modelo. Obtê-lo?
Então, isso é fixe. Então essa é a condição de erro,
e caso contrário fazemos form.save.
Agora a coisa aqui que é realmente super
legal é porque este formulário é
um formulário modelo e
os nomes de campo são os mesmos que
os nomes de campo no modelo,
e então ele realmente faz uma economia no próprio modelo.
Então, de certa forma, o formulário contém os dados do modelo
que vieram da solicitação de postagem e, em seguida, ele salva.
Isso salva o formulário.
Ele o coloca em, e então nós apenas
redirecionar de volta para o URL da solicitação.
Isto é muito sucinto para mim.
Nós puxamos os dados de postagem antigos,
verificamos se é ruim, se é ruim,
enviamos o formulário de volta para
o mesmo modelo
que fizemos e então salvamos se for bom,
e então aparecemos para o URL de sucesso.
Isso é uma coisa linda.
Mas, assim como no Django o tempo todo,
esta é uma coisa muito mais popular a se
fazer, mesmo que isso seja super sucinto.
Se você fizesse isso em quase qualquer outro idioma,
você seria como 75 linhas de código,
e aqui nós temos umas 15 linhas de código.
Mas acontece que no Django há
quase sempre uma maneira mais sucinta de fazê-lo.
Temos uma visão genérica de criação.
Você pode dar uma olhada na documentação para
esta view genérica de criação, django.views.generic.edit.
Vamos procurar no Google essas coisas.
Eu sempre coloco um ponto aqui e isso geralmente
me leva direito a porque
esse é o pacote real e a classe dentro
do pacote. Oh, não.
Desculpe. Você pensou que era um nome de domínio,
então a busca não funcionou.
Mas agora eu vou apenas dizer Django,
algo
que pelo menos vai fazer com uma pesquisa para mim,
views de edição genérica saltar para o CreateView.
Então você pode ler através de todas essas coisas,
CreateView genérico na verdade.
Eu tenho uma referência a isso?
Então, lá vai você. Dê uma olhada nisso.
Agora, isso assim como
alguns dos outros pontos de vista que herdamos,
tem uma tonelada de funcionalidade neles.
Então, se eu quiser fazer uma Criação Automática,
isso é tudo o que é preciso.
Agora, AutoCreate e MakeCreate
para todas as intenções e propósitos,
faça exatamente a mesma coisa.
Então, o que acontece na Criação Automática
porque estamos estendendo o CreateView
,
temos três bits de metadados, dizemos
qual modelo queremos usar, quais campos desse modelo queremos
e onde está a URL de sucesso.
Então isso gera todo esse código.
Herdamos todo esse código.
Você vai notar que não há nada codificado
aqui exceto o MakeForm.
Agora, nós nem sequer temos que fazer um formulário para o Auto
porque este código aqui constrói o formulário.
Não só isso, mas ele usa esse nome
Auto para escolher o modelo.
Então, se eu fizer auto_form,
eu tenho que usar isso.
Eu uso isso, esse é o meu bootstrap base.
Não se preocupe muito com isso.
Então ele sabe o nome
do modelo que ele vai usar.
Eu só tenho que dizer qual modelo usar aqui,
porque ele deriva o modelo,
auto_form.html é o modelo.
Bastante fixe. Bastante incrível e legal.
Então ele automaticamente encontra isso e o success_url.
Então isso é tudo o que é necessário.
Na verdade, neste MakeCreate,
eu poderia ter excluído todo esse código daqui até aqui,
mas em vez disso apenas fazer um CreateView estendendo CreateView.
Só estou te mostrando isso porque quero que
veja o que realmente está acontecendo.
Mas não é assim que se escreve o seu código.
É assim que se escreve o seu código.
Então, agora, eu quero mostrar a vocês
a maneira difícil de fazer uma Atualização.
Então, o que é uma Atualização? Vamos dar uma olhada no código.
Então vamos dar uma olhada nas marcas de visão.
Atualização é a coisa que
acontece quando vamos aqui e
que vai para MakeUpdate.
Então aqui está MakeUpdate, aqui está urls.py. É este aqui.
Quero dizer, procure a atualização da chave primária,
que então se você olhar aqui embaixo,
vai ser carros procurar uma Atualização.
Então, eu vou atualizar o Chevy.
Ele tem que ler os dados antigos,
tem que mostrá-los para você,
e então vamos atualizá-lo e, em seguida, enviá-lo verificando,
é claro, para quaisquer erros de validação.
Em seguida, redirecionando-nos de volta para um success_url.
Então, se
olharmos para os pontos de vista, vamos de novo,
prefigurando, há uma maneira muito mais fácil de fazer isso.
Então, definimos essas variáveis ou o success_url,
qual modelo queremos, e o modelo.
Então temos um pedido de “get”.
Porque no urls.py há este int:pk,
foram passados neste valor pk.
Agora, este get_object_or_404 é muito legal.
Este get_object_or_404 (self.model pk=pk).
Esse é o parâmetro que estamos passando
pk igual e é comum que eles sejam o mesmo nome,
mas este é um parâmetro para get_object_or_404.
Este segundo é o parâmetro
que foi chamado para o nosso get.
Self.Model, é claro, é fazer.
Get_Object_or_404 basicamente verifica se,
eu vou fazer essa atualização,
vamos para marcas, vamos fazer uma atualização.
O que está fazendo é pegar esse número,
este três aqui, autos/lookup/3/update,
e está recuperando os dados antigos.
Agora, o que acontece se eu
inadvertidamente tiver um número
que não existe no banco de dados,
como 9.999, e eu fizer um pedido para esse?
Eu recebo “Página não encontrada 404.”
Então o que está acontecendo aqui é de alguma forma você diz, “Ei,
carregue este objeto e dê a mim e à variável
, faça, ou simplesmente exploda e envie um erro 404.”
Então isso está dizendo o que está acontecendo,
que você apenas, “No Make corresponde à consulta dada.”
Agora, geralmente você não deve digitar isso à mão.
Três funciona, e assim não explode.
Então get_object_or_404 é uma maneira de carregar
os dados antigos e, em seguida,
proteger usando esses dados, ou simplesmente explodir.
Então, não vá mais longe nesse ponto.
Agora, então vamos fazer
um formulário e vamos preenchê-lo com os dados antigos.
Então instância, o que a instância é make.
Então esse é o objeto.
Faça um MakeForm. Aqui está um MakeForm.
Todos os campos do modelo
herdam do modelo Make.
Em seguida, passá-lo para o modelo make_form.html,
que acabamos de olhar.
Esta forma vem, é tudo o que precisamos.
Isto é muito genérico.
Realmente não se importa muito.
É tudo praticamente codificado nesta forma,
que é derivado do modelo.
Então, é claro, nós digitamos um monte
de coisas e nós apertamos “Enviar”.
Ele faz exatamente a mesma coisa que o Criar,
e que ele faz bem.
Primeiro ele tem que fazer um get ou 404 porque
postamos para a coisa com a chave primária.
Nós o carregamos para ter certeza de que temos um objeto para atualizar.
Em seguida, criamos um novo formulário make
a partir desse banco de dados e, em seguida, alterá-lo.
Então isso é como os dados iniciais,
mas então ele altera-os para os dados.
Então, neste caso particular,
Chevrolet é o valor antigo no banco de dados.
Se eu disser Bowtie,
solicitar pós-laboratório Bowtie,
isso vai começar um Chevrolet, mas neste
objeto forma, então ele será Bowtie.
Claro, se não for válido,
retornaremos uma mensagem de erro aqui.
Se for válido, nós vamos
salvá-lo e então este novo Bowtie
vai ser salvo lá dentro.
Então, se
visualizarmos nossas marcas, vemos que agora é Bowtie,
e vamos redirecionar para URL de sucesso.
Agora, neste momento,
eu espero que você possa prever
sobre o que vai acontecer a seguir.
AutoUpdate, estende a exibição de atualização,
a exibição de edição genérica.
Ele diz qual modelo é,
quais campos você quer, e
onde ir quando for bem sucedido.
Então faz tudo o que está aqui.
Literalmente, eu poderia ir e dizer
exatamente as mesmas palavras para fazer excluir,
que é o que acontece quando você entra aqui
e você exclui e então você tem um cancelamento,
há uma confirmação excluir.
O nome deste modelo não é escolhido aleatoriamente,
ele tem que ser chamado de confirm.delete,
o modelo confirm.delete.
Lá vai você. Você tem que o token CSRF.
Você é entregue a marca como um objeto nisso.
Então isso produz essa saída.
Não há forma neste.
Há apenas o make que é carregado por
objeto ou 404 e, em seguida, ele passa make in e renderiza-o.
Então, quando o post acontece, ele recupera-o.
Se ele estiver lá, um 404 novamente
verificando se há dados inválidos e excluindo-os
e, em seguida, saltando para o URL de sucesso.
Não é preciso muito para adivinhar o que vou fazer a seguir,
e isto é, se você estender a exibição de exclusão,
você obtém todo esse código de graça.
Basta dizer quais campos de modelo
e onde ir para o sucesso.
Então a coisa mais importante é,
enquanto
estão fazendo seus trabalhos de casa, tenho certeza que alguns de vocês vão copiar e
colar tudo isso. Isso é errado.
O MakeCreate, MakeUpdate e
MakeDelete deve ser
tão curto quanto AutoCreate, AutoUpdate e AutoDelete.
Porque você vai fazer essas
visualizações genéricas de edição muito e
nós vamos fazer CRUD uma e outra vez,
e você realmente não quer escrever 15 linhas de código.
Isso é repetição desnecessária, corte e
colagem desnecessários e alteração de código se
você puder mantê-lo realmente simples.
Então eu posso basicamente construir um conjunto completo de
formulários CRUD e funcionalidade CRUD com
validação para um modelo com
este código e então eu nem sequer tenho que ter um forms.py,
eu só tenho um models.py.
Então, se você está fazendo seu Autos,
você pensaria que eu cometi
um erro se eu estou fazendo um forms.py.
Porque se eu usar esse views.py dessa maneira,
em vez de fazer com que todos eles pareçam MakeUpdate,
então você vai economizar muito
tempo e energia e nós temos que modificar essas coisas.
É muito mais fácil encontrar
todas as alterações e depois modificá-las.
Então isso é um passo a passo do código de exemplo para Autos.
Você vai fazer uma tarefa sobre isso,
mas não copie tudo.
Eu preparei isso para que o
tempo que você passa entendendo o que está acontecendo,
particularmente nas vistas.
URL é o seu orgulho apenas copiar,
modelos que você acabou de copiar,
os URLs que você acabou de copiar,
mas as visualizações não apenas copiá-lo,
descobrir o que realmente está acontecendo e vir acima com
a maneira mais fácil e mais sucinta de fazer todas essas coisas.
O Django está começando a ficar
muito bonito neste momento.
Espero que tenha achado isso útil. Saúde.