Bonjour et bienvenue dans un autre Django
pour que tout le monde marche à travers.
Donc, vous êtes probablement à ce stade à
travailler sur votre affectation d'autos.
Il s'agit de notre première vraie création,
lecture, mise à jour et suppression.
Beaucoup de ce que cette affectation est,
est de regarder le code
que je vous ai donné dans les échantillons DJ4E et de le tirer dedans.
Ne clonez pas le référentiel pour cette affectation.
Les Samples DJ4E sont un monstre.
Il y a toutes sortes de choses dedans,
c'est beaucoup trop complexe et vous ne voulez pas.
Vous voulez commencer par une application agréable et propre.
Votre mission précédente était de faire
une très petite application vers le bas,
nous allons étendre cette application.
C' est pourquoi vous avez déjà
ces projets DJ4E partout où il se trouve.
Donc, ce que c'
est, c'est
que cette affectation est d'évoluer en utilisant l'exemple de code.
Mais ce que je vais vraiment
faire, c'est que je vais parcourir
l'exemple de code car il y a de
nouveaux concepts dans cet exemple de code.
C' est donc plus une conférence sur
l'exemple de code que sur la façon de faire l'affectation.
Mais surtout, vous devez
comprendre chaque ligne parce que littéralement,
chaque programme que nous allons écrire pour
les n prochaines semaines est une variation sur ce CRUD.
Donc, ces vues par défaut,
le get 404,
tous ces trucs sont vraiment une base dans beaucoup de choses.
Ce que nous allons trouver est la
bonne façon d'écrire ce code,
comme tout dans Django,
est vraiment petit et succinct.
Jetons donc un coup d'oeil au code.
Allons de l'avant et exécutons le code.
Allez dans les autos, et vous devez vous connecter.
Donc, l'idée est qu'il y a deux tables.
Il y a une table de marques.
Donc, je vais ajouter une marque
et puis je vais ajouter une auto,
et le truc cool à ce sujet, c'est Neon
1, kilométrage 1,234, SakalCard.
Ensuite, j'ai ce menu déroulant cool.
Donc il y a tout un tas de formulaires qui se passent ici,
il y a des listes déroulantes, il y a beaucoup
à une relation en cours.
Ensuite, j'ai cette liste et je peux la mettre à jour et la supprimer.
C' est là que se trouve notre CRUD complet.
Donc, nous pouvons ajouter des marques,
voir des marques, ajouter des autos, etc.
Donc c'est tout l'échantillon.
Donc c'est très proche de ce qu'il est que vous devez écrire,
c'est juste ne pas aller saisir et tout ça.
Alors commençons par jeter un oeil.
Donc je suis ici assis dans mes échantillons DJ4E.
Si vous regardez, vous voyez toutes
mes différentes applications sous un projet.
Donc nous avons les autos,
mais je veux vraiment commencer par le code d'authentification,
si je retourne ici aux échantillons,
laissez-moi me déconnecter, le code qui me permet de me connecter.
Donc si je vais directement aux voitures pour voir si je me suis déconnecté.
Vous remarquerez que ce qu'il fait
quand je vais directement aux autos,
c'est qu'il me dirige pour me connecter,
puis avec le suivant pour revenir à l'auto.
Donc, cette vue dans les autos,
le /autos s'est protégé avec le mixage de connexion.
Plus tard, nous ferons une connexion,
votre login ne ressemblera pas tout à fait à
ceci, mais c'est celui que j'ai sur les échantillons.
Vous n'avez pas encore à le rendre joli,
une affectation à venir va tout rendre joli.
Maintenant, nous sommes chez les autos et nous sommes connectés.
Votre application doit avoir plus de choses ici,
mais je suis plus intéressé à
vous montrer vraiment l'essence des
vues dans cette autos.
Examinons simplement brièvement comment fonctionne la connexion automatique.
Donc, si je regarde dj4e-samples/settings.py,
vous devez avoir cette authentification branchée.
Donc, c'est fondamentalement un tas de code, quelques vues
, etc., qui vient de Django,
et cela a été là depuis le
début de votre projet.
Bien sûr, alors quelque part ici,
il faut avoir les voitures, où qu'elles soient.
Ouais, autos app config,
vous devez tirer l'application autos dedans.
Si je regarde dj4e-samples/urls.py,
alors je peux trouver des autos ici,
et il doit y avoir une ligne qui dit fondamentalement,
« Au niveau supérieur,
tout ce qui suit autos est délégué
au fichier urls dans autos.py.
Mais il y a aussi les comptes. »
Donc, si vous vous souvenez,
c'est un tas de vues qui viennent de Django pour nous,
il est pré-installé pour nous.
La chose que nous devons faire est que nous devons
fournir à ce modèle
avec le nom registration.html.
Donc, je pense que j'ai ceci à la maison/templates/inscription/.
Oui, je le sais. Donc j'ai en fait deux connexions.
J' en ai un très simple comme login.html.
C' est celui que je vous recommande de commencer par.
Plus tard, nous utiliserons la connexion sociale. C'est très simple.
Il s'agit d'une page de connexion qui utilise la fonctionnalité de formulaires Django.
Si des erreurs sont formées,
cela signifie qu'il y a une erreur de validation.
Il est revenu et ré-affiché
cette page et vous a montré une erreur.
Ensuite, nous faisons un formulaire de publication simple avec une URL
qui est une recherche inverse à une vue avec un nom de connexion.
Ensuite, nous mettons le jeton CSRF et puis nous prenons le formulaire,
et je fais juste cela avec des balises de paragraphe.
C' est donc un simple login,
ce n'est pas le vrai que nous montrons.
Ensuite, la suivante est une valeur cachée que vous devez transmettre
afin que lorsque vous vous connectez avec succès,
elle sache revenir aux autos.
Quand tout est fait, il revient
ici une fois la connexion terminée.
Pour que l'enregistrement/connexion,
vous pouvez le mettre dans n'importe laquelle de vos applications,
mais vous voulez le nommer registration/login.html.
Donc, si je jette un coup d'oeil très rapide
et que je vais dans la maison/templates,
ce sont tous les modèles.
Quand je fais un ls, vous verrez que j'ai
une maison/templates/maison et une maison/modèles/inscription.
Vous pouvez avoir plus d'un dossier ici.
Si je regarde ce qui est dans l'enregistrement,
vous voyez que j'ai cette connexion simple, puis plus tard
la connexion plus complexe qui nous donnera
les capacités de connexion GitHub.
Donc, ce que cela signifie est l'utilisation de connexion sociale.
Le point est en dessous de ces modèles,
vous n'avez pas besoin d'avoir juste un sous-dossier,
vous pouvez avoir plus d'un sous-dossier.
Donc, c'est la configuration nécessaire pour le faire de sorte
que lorsque nous disons à nos vues d'ajouter le mixin de connexion,
que nous verrons en seulement une seconde.
Nous disons nos vues dans la connexion pour utiliser le mixin de connexion,
puis il sait d'où obtenir le modèle.
Donc c'est juste une partie de ça et
vos instructions vous disent comment faire ça.
Donc, toute application que vous allez
construire ou tout projet que vous allez construire,
vous devez les mettre dans les paramètres py,
urls.py, puis faire le modèle.
Ensuite, vous devez commencer à utiliser
login mixin et puis tout
commence par magie à se réunir.
Jetons donc un coup d'oeil à l'application automobile réelle.
Nous allons regarder quelques choses différentes
ici, autos/urls.
Je vais faire un onglet multi-terminal,
donc je peux revenir d'un fichier à l'autre très vite.
Vous avez probablement un meilleur éditeur de texte que moi.
J' ai donc des URL,
je vais jeter un oeil au autos/views.py.
Ensuite, je vais regarder autos/model.py.
Ensuite, je vais regarder autos/forms.py.
Travaillons donc à travers ces quatre fichiers,
URL, vues, modèles, formulaires.
Probablement faisons des modèles d'abord.
Donc, c'est assez simple.
Nous allons faire une classe d'objet Make.
Il va avoir un champ de caractères
avec quelques validateurs dedans.
On joue avec ça avec les formes.
Vous pouvez mettre des validateurs dans des modèles.
Nous avons déjà vu des validateurs sous forme,
mais il y a un validateur qui dit fondamentalement,
nous n'accepterons pas les données entrant dans
cette table de base de données à moins qu'
il n'y ait au moins deux caractères.
Ce _str_, vous le faites depuis un moment.
C' est fondamentalement si vous prenez
un objet modèle une marque réelle et que vous l'imprimez,
il indique lequel des champs,
dans ce cas, il n'y a qu'un seul champ.
Donc, cela dit juste lorsque nous convertissons
un objet modèle en une chaîne,
nous pouvons décider à quoi cela ressemble.
Ensuite, nous avons une automobile et il a
un surnom avec un minLengthValidator, max_length de 200,
et kilométrage, qui a un champ entier, un commentaire,
qui est un champ de 300 caractères,
puis une clé étrangère dans aussi.
Ceci comme une relation un-à-plusieurs ou plusieurs-à-un,
pas une plusieurs-à-plusieurs, juste une clé étrangère dans Make.
Ensuite, nous allons on_delete
CASCADE, ce qui signifie vraiment que si vous supprimez un Make,
alors les entrées automatiques correspondantes
seront automatiquement supprimées.
C' est donc un modèle assez simple,
en fait très, très simple.
Encore une fois, nous définissons toujours
ce _str_ (self) afin que nous sachions que si vous le
montrez simplement comme dans l'
interface d'administration ou si vous l'
imprimez simplement ou simplement
convertissez le modèle lui-même en chaîne,
le champ parmi ces champs qui
est censé être utilisé est le ,
juste pour montrer aux utilisateurs finaux.
C' est donc le fichier des modèles.
Regardons le fichier de formulaires suivant.
Donc, le fichier de formulaire est intéressant,
parce que nous avons vu des formulaires qui
ne sont que des formulaires par eux-mêmes,
mais c'est un type spécial de
formulaire et puis c'est un ModelForm.
En cela, nous avons normalement dans les autres modèles,
nous avions tous ces champs,
et nous les avons mis et cela ressemblait
beaucoup à un fichier modèle où nous
avons un champ de caractères, PositiveIntegerField.
Mais ce qu'on dit, c'est que tu sais quoi ?
On va faire un formulaire ici.
Vraiment, tout ce que nous voulons faire est de prendre
tous les champs
du modèle Make et de les faire former des champs.
Donc, une forme et un modèle sont deux choses différentes.
Un formulaire est quelque chose qui va
entre la vue et le modèle,
et comme vous le verrez,
il descend également automatiquement dans les modèles,
donc c'est exactement comme faire tous les champs.
Faisons un formulaire car les
objets de formulaire n'ont pas besoin d'être associés à des modèles.
Mais dans ce cas, nous allons
dériver un objet de formulaire à partir d'un modèle.
Donc, au lieu d'étendre la forme, nous étendons ModelForm.
Donc, c'
est un ModelForm doit avoir, et ce sont juste quelques données qui disent que le modèle que nous
allons extraire tous nos champs est le modèle Make,
et il n'a qu'une chose qui est un nom.
C' est ça. Donc, cela génère automatiquement
un formulaire que si
nous l'avons modifié et ajouté un autre champ ici,
alors ce formulaire de marque aurait automatiquement un champ.
Vous pouvez lui donner une liste de champs,
_ _ tous _ _ est
comme un signal pour dire, « Donnez-moi juste tous. »
Maintenant, il peut y avoir
des choses internes comme créé et
mis à jour à ou quelque chose que vous ne voulez pas utiliser.
Donc c'est un formulaire, rappelez-vous comment les formulaires fonctionnent.
On couvre ça avant. Jetons un coup d'oeil à nos URL.
Maintenant, beaucoup de choses
ressemblent à des choses que nous avons faites.
Nous avons essentiellement une table principale,
qui est notre table d'autos,
et notre table de recherche, qui est notre table de make.
Ensuite, nous avons trois choses,
il y a la vue de liste principale,
qui est la liste de toutes les voitures.
Il y a la vue principale de la liste Make,
qui est la liste de toutes les marques.
Ensuite, nous pouvons en faire
une nouvelle qui n'a pas de clé primaire,
parce qu'une partie des idées qui
créent est de faire une nouvelle chose,
qui va générer une clé primaire.
Ensuite, nous allons avoir une mise à jour et une suppression.
Donc, nous avons une lecture, créer, mettre à jour, supprimer.
Donc ce n'est pas exactement cred,
mais vous voyez les quatre choses.
Nous avons donc des vues,
et nous nommons ces vues afin que nous puissions
les référencer dans nos vues
elles-mêmes et dans notre modèle
afin que nous puissions établir des liens entre elles.
Donc, ceux-ci sont assez
simples et pas si différents.
Donc, le plaisir commence à se produire quand nous sommes dans le views.py.
Donc, connectez-vous mixin,
si vous vous souvenez de l'auteur de z walk-through,
vous ajoutez simplement ceci à une vue et il
dit simplement que vous ne pouvez pas accéder
à cette vue sauf si vous êtes connecté
et si vous n'êtes pas connecté,
il va bosser dans le
fichier login.html, puis rebondir après que vous êtes fait.
Donc LoginRequiredMixin est tout ce que nous devons faire.
Si vous allez à l'échantillon z de l'auteur,
vous verrez comme je l'ai fait à la main.
Tu ne veux pas le faire à la main,
tu appelles juste login mixin.
Maintenant, donc cette vue principale est une vue de liste,
et donc allons jeter
un oeil à quoi cela va ressembler.
Il s'agit de la vue Liste.
Donc, nous allons prendre les nombreux audits que nous
avons, nous allons parcourir cette liste,
nous allons récupérer tous les audits de la base de données.
Ensuite, nous allons avoir un ajouter le lien automatique,
puis une vue qui
fait le lien avec un compte de combien il y a et ajouter une marque.
Alors laissez-moi aussi ensuite aller dans les modèles d'autos, les
autos à nouveau, et la liste automatique.
Donc, c'est le modèle qui fait cela.
Donc il y a quelques choses que nous obtenons,
nous avons une liste de voitures.
Maintenant, les noms de ceux-ci ne vous sont pas forcés,
mais il y a des conventions qui se révèlent dans un instant,
nous allons avoir l'air vraiment utile.
Donc on va avoir une liste de voitures.
Si nous revenons dans nos vues,
nous voyons que nous disons,
obtenez tous les objets de la table auto,
tous les objets de classe automatique les récupèrent tous,
les passé dans le contexte en tant que auto_list.
Maintenant, nous voulons aussi être en mesure de
montrer ce petit compte, c'est le numéro deux,
donc nous allons demander,
aller de l'avant aux objets de fabrication
tous, mais ne me donnez pas une liste d'entre eux,
comptez-les et donnez-moi un numéro.
Donc make count est coincé là-dedans et vous
verrez si peut compter est supérieur à zéro.
Nous pouvons montrer l'annonce et le bouton automatique,
et il montre aussi quelque part le make
count, voir toutes les marques, ajouter une marque,
et le make count sort ici.
Donc c'est une autre chose qu'on a mise.
La liste automatique que nous allons parcourir et cette
variable d'itération d'auto va
passer par chacune des choses séparées,
et le surnom, make, etc,
c'est tout droit sorti du fichier models.py.
Il y a les quatre choses que toutes les voitures ont,
et nous imprimons tout ça.
Vous obtenez également la clé primaire,
et donc nous allons faire une URL de mise à jour,
et cette URL est à autos : auto_update.
Donc, si vous regardez dans urls.py,
nous voyons cette mise à jour automatique recherche,
cela nous donne un chemin vers la vue,
mais ce chemin particulier
a besoin d'un paramètre qui est une clé primaire, ce qui signifie que cette balise de modèle d'URL, autos doit avoir l'auto.id. à travers les modèles,
vous en avez un, et vous faites un auto_create,
c'est assez simple.
Mais l'une des règles est, est que vous devez avoir
au moins une marque avant de pouvoir faire une auto,
parce que si vous vous souvenez,
ajouter une auto doit avoir
cette liste déroulante populable et
cela est tiré de la table make,
et donc c'est fondamentalement la façon de contourner cela.
C' est la vue principale.
On y va, mise à jour.
C' est la vue autos, et si on fait la vue make,
on fait la même chose.
Si nous allons regarder la liste de marques,
nous faisons la même chose de base,
voir toutes les marques,
et maintenant nous avons mis à jour et supprimer.
De cette façon, vous n'avez pas besoin de compter.
Nous voulons juste saisir tous les objets,
nous voulons le mettre dans un contexte sous make list,
puis nous faisons la liste sur le HTML,
et c'est encore plus simple.
Il passe juste par la liste de marques,
il vient à travers le contexte.
S' il n'y en a pas, nous n'imprimons pas cela,
puis nous mettons le nom de celui-ci,
et puis nous avons une mise à jour et un bouton de suppression
qui va à la mise à jour et la suppression,
et bien sûr, si vous regardez dans urls.py,
ceux aussi la mise à jour et la suppression
ont des exigences de clé primaire,
et donc vous
avez une clé primaire que vous devez passer ici
pour faire de cette URL l'URL appropriée,
puis juste quelques liens pour
revenir aux différentes choses afin que
nous puissions revenir aux autos,
voir les marques, ajouter une nouvelle marque.
Maintenant, annulez tout ça.
Donc, c'est le views.py
pour lister les autos et les marques.
Maintenant, nous voulons faire de la vue make create.
Donc, si nous jetons un oeil à la vue make create,
c'est-à-dire ajouter une marque.
Ça va créer ce formulaire.
Je peux agrandir ça ici.
Il peut créer cette forme,
où nous allons mettre une chose appelée Chevy.
Nous avons donc besoin d'un moyen de faire ce formulaire.
Nous allons en faire un login requis,
nous ne allons pas laisser les gens faire ça.
Nous allons avoir quelques variables qui sont à l'échelle de la classe,
comme le modèle que nous voulons utiliser,
et success_url est après que nous avons fait cela correctement.
Maintenant, si vous le soumettez
et qu'il se plaint, il ne le fait pas.
Mais une fois que vous avez bien fait,
où voulez-vous aller après ?
Alors Chevy, où veux-tu aller après ?
Ceci est la fonction de contrôleur.
Je veux revenir à la liste automatique,
et donc le success_url va
à autos:tout ce qui dans urls.py est cette vue principale.
C' est le nom de la vue principale,
et donc si nous allons ici,
quel modèle utiliser et quel success_url.
Si nous faisons une demande get,
nous allons construire un formulaire pour
le make qui vient de make form,
mais vraiment il vient du modèle make,
qui est juste un champ de chaîne.
Aussi simple que ça. On réutilise ça.
Nous disons juste, faisons un formulaire
qui tire d'ici.
Nous devons transmettre un formulaire,
car les modèles ne peuvent pas être utilisés pour créer cet écran.
Cet écran vient d'un formulaire.
D' accord. Si nous jetons un coup d'oeil au modèle,
si nous regardons le faire créer
modèle ou faire forme.
C' est donc le modèle que nous allons utiliser pour créer la forme.
Nous allons avoir besoin de form_as_table.
Donc c'est de la façon dont nous avons fait des formulaires.
Mettez le jeton CSRF,
vous créez une table,
qui pourrait être sous forme de paragraphes ou de tables.
Mais peu importe, vous avez besoin de cet objet de formulaire.
Donc, vous devez passer l'objet de formulaire dans.
Donc, nous voilà, nous allons faire un formulaire,
puis nous allons à l'objet formulaire dans,
puis nous allons rendre à self.template
autos.makeform html.
Ensuite, nous allons rendre ça pour le get.
Ensuite, quand nous appuyons sur
le bouton le bouton de soumission, Ajouter une marque,
nous appuyons sur le bouton
de soumission, il vient dans le poste
parce que nous avons fait un post de formulaire, vient.
Ne fais pas ça. C'est terrible.
Je déteste quand vi fait ça.
Mais on y va, on est de retour.
Oui. Donc post arrive,
request.post a toutes les paires de valeur clé
qui sont ces paires clé-valeur telles que définies par le formulaire.
Donc, nous disons que nous allons faire un formulaire de marque avec
les données initiales provenant de la poste de requête.
Étant donné que le formulaire l'a généré,
il sait quels sont les noms de ces champs,
et c'est quelque chose qui se cache derrière le fonctionnement des formulaires.
Mais il vérifie également si les données du formulaire sont valides et
cela signifie que nous sommes toutes ces règles de validation suivies.
Si les règles du validateur ne sont pas respectées,
si le formulaire n'est pas valide,
nous allons simplement le renvoyer.
Donc ce code ici,
ce formulaire n'est pas un code valide.
Si je mets une seule lettre A et appuie sur « Soumettre »,
il va revenir et re-rendre
le formulaire et toutes ces erreurs, tout ce
truc est géré par ce code de formulaire,
ce code de formulaire Django découvre ce qui ne va pas.
Juste un peu pour que je puisse y
revenir plus vite. On y va.
Il détermine ce qui ne va pas,
fait un message d'erreur,
le message d'erreur est venu de models.py ici.
Non, juste ici.
Puis passé par forms.py parce que c'est
une forme en fin de compte que nous avons hérité de la
forme du modèle. L'avoir ?
Donc c'est cool. C'est donc la condition d'erreur,
et sinon nous formons .save.
Maintenant, la chose qui est vraiment super
cool ici est parce que ce formulaire est
un formulaire de modèle et
les noms de champs sont les mêmes que
les noms de champs dans le modèle,
et donc il fait réellement un enregistrement sur le modèle lui-même.
Donc, d'une certaine manière, le formulaire contient les données de modèle
qui proviennent de la demande de publication et ensuite il l'enregistre.
Cela enregistre le formulaire.
Il le met dans, puis nous
redirigeons simplement vers l'URL de la requête.
C' est assez succinct moi.
Nous extrayons les anciennes données de post,
nous vérifions si c'est mauvais, si c'est mauvais,
nous renvoyons le formulaire au
même modèle que nous l'avons
fait, puis nous l'enregistrons si c'est bon,
puis nous allons à l'URL de succès.
C' est une belle chose.
Mais tout comme à Django tout le temps,
c'est une chose beaucoup plus grave à
faire, même si c'est super succinct.
Si vous l'avez fait dans presque n'importe quelle autre langue,
vous seriez comme 75 lignes de code,
et ici nous avons comme 15 lignes de code.
Mais il s'avère qu'à Django, il y a
presque toujours une façon plus succincte de le faire.
Nous avons une vue de création générique.
Vous pouvez jeter un oeil à la documentation de
cette vue de création générique, django.views.generic.edit.
Allons-y et Google ce truc.
Je mets toujours juste un point ici et cela
me fait généralement droit parce
que c'est le paquet réel et la classe à l'intérieur
du paquet. Oh, non.
Désolé. Vous pensiez que c'était un nom de domaine,
donc la recherche n'a pas fonctionné.
Mais maintenant, je vais juste dire Django,
quelque chose donc au moins
ça va faire avec une recherche pour moi, les
vues d'édition génériques sauter à CreateView.
Donc, vous pouvez lire toutes ces choses,
CreateView générique en fait.
Est-ce que j'ai une référence à ça ?
Alors, voilà. Jetez un oeil à ça.
Maintenant, comme
certaines des autres vues que nous avons héritées,
ont une tonne de fonctionnalités en eux.
Donc, si je veux faire une création automatique,
c'est tout ce qu'il faut.
Maintenant, AutoCreate et MakeCreate à
toutes fins utiles,
faites exactement la même chose.
Donc, ce qui se passe dans
AutoCreate parce que
nous étendons CreateView, nous avons trois bits de métadonnées,
nous lui disons quel modèle nous voulons utiliser,
quels champs de ce modèle nous voulons,
et où se trouve l'URL de succès.
Ensuite, cela génère tout ce code.
Nous avons hérité de tout ce code.
Vous remarquerez qu'il n'y a rien de codé
en dur ici sauf le MakeForm.
Maintenant, nous n'avons même pas besoin de créer un formulaire pour l'Auto
parce que ce code ici construit le formulaire.
Non seulement cela, mais il utilise ce nom
Auto pour choisir le modèle.
Donc, si je fais auto_form,
je dois utiliser ceci.
J' utilise ceci, c'est mon bootstrap de base.
Ne vous inquiétez pas trop à ce sujet.
Donc, il connaît
le nom du modèle qu'il va utiliser.
Je n'ai qu'à lui dire quel modèle utiliser ici,
car il dérive le modèle,
auto_form.html est le modèle.
Plutôt cool. Plutôt génial et cool.
Donc, il trouve automatiquement cela et le success_url.
Donc c'est tout ce qu'il faut.
En fait, dans ce MakeCreate,
j'aurais pu supprimer tout ce code d'ici à ici,
mais plutôt faire un CreateView en étendant CreateView.
Donc je te montre ça parce que je veux que tu
vois ce qui se passe vraiment.
Mais ce n'est pas ainsi que vous écrivez votre code.
C' est ainsi que vous écrivez votre code.
Alors maintenant, je veux vous montrer
la façon difficile de faire une mise à jour.
Qu' est-ce qu'une mise à jour ? Jetons un coup d'oeil au code.
Alors jetons un coup d'oeil à la vue fait.
La mise à jour est la chose qui
se passe quand nous allons ici et
qui va aller à MakeUpdate.
Donc voici MakeUpdate, voici urls.py. C'est celui-là.
Je veux dire, cherchez la mise à jour de la clé primaire,
qui alors si vous regardez en dessous,
ce sera des autos recherchant une mise à jour.
Je vais mettre à jour le Chevy.
Il doit lire les anciennes données,
doit vous les montrer,
puis laissez-nous les mettre à jour et ensuite soumettre la vérification,
bien sûr, pour toute erreur de validation.
Puis nous rediriger vers un success_url.
Donc, si nous regardons les vues,
nous allons à nouveau,
préfigurant, il y a un moyen beaucoup plus facile de le faire.
Nous définissons donc ces variables ou le success_url,
quel modèle nous voulons, et le modèle.
Ensuite, nous avons une demande get.
Parce que dans le urls.py il y a cet int:pk,
ont été passés dans cette valeur pk.
Maintenant, ce get_object_or_404 est vraiment cool.
Cette get_object_or_404 (self.model pk=pk).
C' est ce paramètre que nous passons
pk égal et il est fréquent qu'ils soient le même nom,
mais c'est un paramètre pour get_object_or_404.
Ce second est le paramètre
qui a été appelé à notre get.
Self.Modèle, bien sûr, est la marque.
get_object_or_404 vérifie essentiellement si,
je vais faire cette mise à jour,
passons à make, faisons une mise à jour.
Ce qu'il fait, c'est qu'il prend
ce nombre, ces trois ici, autos/lookup/3/update,
et il récupère les anciennes données.
Maintenant, que se passe-t-il si j'ai
par inadvertance un nombre
qui n'existe pas dans la base de données,
comme 9,999, et que je fais une demande get à celui-là ?
Je reçois « Page introuvable 404. »
Donc, ce qui se passe ici, c'est en quelque sorte que vous dites, « Hé,
chargez cet objet et donnez-le à moi et à la variable
, faites, ou simplement explosez et envoyez une erreur 404. »
Donc, cela vous dit ce qui se passe,
qui vous voit juste, « No Make correspond à la requête donnée. »
Maintenant, en général, vous n'êtes pas censé taper ces mains.
Trois ça marche, et donc ça ne explose pas.
Donc get_object_or_404 est un moyen de charger
les anciennes données, puis de
protéger en utilisant ces données, ou simplement de sauter.
Alors n'allez pas plus loin à ce moment-là.
Maintenant, nous allons faire
un formulaire et nous allons le remplir avec les anciennes données.
Ainsi, par exemple, ce que l'instance est faite.
Donc c'est l'objet.
Créez un MakeForm. Voici un MakeForm.
Tous les champs du modèle
héritent du modèle Make.
Ensuite, passez le dans le modèle make_form.html,
que nous venons de regarder.
Ce formulaire arrive, c'est tout ce dont nous avons besoin.
C' est très générique.
Ça ne s'en fout vraiment pas trop.
Tout est à peu près codé dans cette forme,
qui est dérivé du modèle.
Alors bien sûr, on tape un tas de trucs
et on touche « Soumettre ».
Il fait exactement la même chose que le Create,
et qu'il fait bien.
D' abord, il doit faire un get ou 404 parce que
nous posons à la chose avec la clé primaire.
Nous le chargeons pour nous assurer que nous avons un objet à mettre à jour.
Ensuite, nous créons un nouveau formulaire
de marque à partir de cette base de données, puis le changeons.
Donc, c'est comme les données de départ,
mais ensuite il les modifie aux données.
Donc, dans ce cas particulier,
Chevrolet est l'ancienne valeur de la base de données.
Si je dis nœud papillon,
demande de labo post-labo,
cela va démarrer une Chevrolet mais dans cette forme
d'objet alors ce sera nœud papillon.
Bien sûr, si ce n'est pas valide,
nous allons retourner un message d'erreur ici.
Si c'est valide, nous allons le sauver
et donc ce nouveau nœud papillon
va être sauvé là-dedans.
Donc, si nous voyons nos marques,
nous voyons que c'est maintenant Bowtie,
et nous allons rediriger vers l'URL de succès.
Maintenant, à ce stade,
j'espère que vous pourriez
prédire ce qui va se passer ensuite.
AutoUpdate, étend la vue de mise à jour,
la vue de mise à jour générique.
Il indique quel modèle il est,
quels champs vous voulez et
où aller quand il réussit.
Ensuite, il fait tout ce qu'il y a ici.
Littéralement, je pourrais aller dire
exactement les mêmes mots pour faire supprimer,
qui est ce qui arrive quand vous allez ici
et vous supprimez et puis vous avez une annulation,
il y a une confirmation de suppression.
Le nom de ce modèle n'est pas choisi au hasard,
il doit être appelé le confirm.delete,
le modèle confirm.delete.
Voilà, tu y vas. Vous avez le jeton CSRF.
On vous remet la marque comme un objet dans ça.
Donc, cela produit cette sortie. Il
n'y a pas de forme dans celui-ci.
Il y a juste le make qui est chargé par
l'objet ou 404, puis il passe make in et le rend.
Ensuite, quand le post arrive, il le récupère.
Si c'est là, un 404
vérifie à nouveau les données erronées et les supprime,
puis saute à l'URL de succès.
Il ne faut pas grand-chose de deviner ce que je vais faire ensuite,
et c'est, si vous étendez la vue de suppression,
vous obtenez tout ce code gratuitement.
Il suffit de dire quels champs de modèle
et où aller pour réussir.
Donc, la clé est
que, comme vous faites vos devoirs,
je suis sûr que certains d'entre vous vont juste copier et
coller tous ces trucs. C'est faux.
Les paramètres MakeCreate, MakeUpdate et
MakeDelete doivent être
aussi courts que AutoCreate, AutoUpdate et AutoDelete.
Parce que vous allez faire
beaucoup ces vues d'édition génériques et
nous allons faire CRUD encore et encore et encore,
et vous ne voulez vraiment pas écrire 15 lignes de code.
C' est une répétition inutile, une coupe et un
collage inutiles et un changement de code si
vous pouvez le garder vraiment simple.
Donc, je peux fondamentalement construire un ensemble complet de
formulaires CRUD et de fonctionnalités CRUD avec
validation pour un modèle avec
ce code et alors je n'ai même pas besoin d'avoir un forms.py,
j'ai juste un models.py.
Donc, si vous faites vos Autos,
vous penseriez que j'ai fait
une erreur si je fais un forms.py.
Parce que si j'utilise juste ce views.py de cette façon,
au lieu de les faire tous ressembler à MakeUpdate,
alors vous allez vous faire économiser beaucoup de
temps et d'énergie et nous devons modifier ces choses.
Il est beaucoup plus facile de trouver
tous les changements, puis de les modifier.
C' est donc une étape de l'exemple de code pour Autos.
Vous allez faire une mission là-dessus,
mais ne copiez pas tout.
J' ai mis en place cela de sorte que le
temps que vous passez à comprendre ce qui se passe,
en particulier dans les points de vue.
L' URL est votre fierté simplement copier, les
modèles que vous venez de copier,
les URL que vous allez copier,
mais les vues ne se contentent pas de le copier,
de comprendre ce qui se passe vraiment et de trouver
la façon la plus simple et la plus succincte de faire tout cela.
Django commence à être
vraiment beau à ce stade.
J' espère que vous avez trouvé cela utile. Les applaudissements.