Здравствуйте и добро пожаловать в другой Django, чтобы
все прошли.
Таким образом, вы, вероятно, на этом этапе
работаете над вашим назначением авто.
Это наше первое реальное
задание для создания, чтения, обновления и удаления.
Многое из того, что это задание,
это посмотреть на код, который
я дал вам в DJ4E Samples, и вытащить его.
Не клонируйте репозиторий для этого назначения.
Образцы DJ4E - монстр.
В нем есть все виды вещей,
это слишком сложно, и вы не хотите.
Вы хотите начать с красивого, чистого приложения.
Ваше предыдущее задание заключалось в том
, чтобы сделать действительно крошечное приложение вниз,
мы собираемся расширить это приложение.
Вот почему у вас уже есть
проекты DJ4E, где бы вы ни находились.
Итак, что это,
это назначение состоит в том, чтобы эволюционировать
это с помощью примера кода.
Но то, что я действительно собираюсь
сделать, это я собираюсь пройти через
образец кода, потому что
в этом примере кода есть новые концепции.
Таким образом, это скорее лекция
о примере кода, чем именно то, как выполнить задание.
Но важно, что вы должны
понимать каждую строку, потому что буквально
каждая программа, которую мы собираемся написать в течение
следующих n недель, является вариацией на этом CRUD.
Таким образом, эти представления по умолчанию
, get 404,
все это действительно основа во многих вещах.
То, что мы собираемся найти, это
правильный способ написать этот код,
как и все в Django,
очень маленький и лаконичный.
Итак, давайте взглянем на код.
Ну, давайте продолжим и запустим код.
Идите в автомашины, и вам нужно войти в систему.
Таким образом, идея этого состоит в том, что есть две таблицы.
Есть таблица марок.
Так что я собираюсь добавить марку,
а затем я собираюсь добавить авто,
и классная вещь об этом, это Neon
1, пробег 1,234, SakalCard.
Тогда у меня есть это крутое раскрывающееся меню.
Так что здесь происходит целая куча форм,
есть выпадающие списки, есть
отношения от многих к одному.
Затем у меня есть этот список, и я могу обновить его и удалить его.
Так вот где наш полный CRUD.
Таким образом, мы можем добавить
makes, view makes
, добавить авто и т. Д.
Так что это очень близко к тому, что вы должны написать,
это просто не хватайте и все такое.
Итак, давайте начнем с взгляда.
Так что я сижу здесь в своих образцах DJ4E.
Если вы посмотрите, вы видите все
мои различные приложения в рамках проекта.
Итак, у нас есть автомобили,
но я действительно хочу начать с кода аутентификации,
если я вернусь сюда к образцам,
позвольте мне выйти, код, который позволяет мне войти в систему.
Так что, если я пойду прямо к автомобилям, чтобы узнать, вышел ли я из системы.
Вы заметите, что то, что он делает,
когда я иду прямо на авто,
это направляет меня на вход,
а затем с рядом, чтобы вернуться к авто.
Таким образом, этот вид в автосах
/autos защитил себя смешиванием логина.
Позже мы выполним вход,
ваш логин не будет выглядеть так,
но это тот, который у меня есть на образцах.
Тебе еще не нужно делать это красиво
, предстоящие задания сделают все красивым.
Итак, теперь мы в автосалонах и мы вошли в систему.
Ваше приложение должно иметь еще несколько вещей здесь,
но мне больше интересно показать
вам действительно суть
представлений в этих автомобилях.
Давайте просто вкратце рассмотрим, как работает автоматический вход.
Поэтому, если я посмотрю на dj4e-samples/settings.py,
вам нужно подключить этот auth.
Таким образом, это в основном куча кода, некоторые представления
и т. Д., Это происходит от Django,
и это было там все
время, когда вы сделали свой начальный проект.
Конечно, тогда где-то здесь,
у нас должны быть автомашины, где бы ни находились машины.
Да, конфигурация приложения для автомобилей,
вы должны вытащить приложение для автомобилей.
Если я взгляну на dj4e-samples/urls.py,
тогда я могу найти авто здесь,
и должна быть строка, в которой в основном говорится:
«На верхнем уровне
все ниже авто делегируется
в файл URL-адресов в autos.py.
Но и тогда есть счета».
Так что, если вы помните,
это куча просмотров, которые приходят от Django для нас,
она предустановлена для нас.
То, что мы должны сделать, это мы должны
предоставить этому шаблону
с именем registration.html.
Поэтому я думаю, что у меня есть это дома/шаблоны/регистрация/.
Да, я знаю. Так что у меня на самом деле два входа.
У меня очень простой, как login.html.
Это тот, с которого я рекомендую начать.
Позже мы будем использовать социальный логин. Это очень просто.
Это страница входа в систему, которая использует возможности форм Django.
Если возникли ошибки,
это означает, что есть ошибка проверки.
Он вернулся и снова отобразил
эту страницу и показал вам ошибку.
Затем мы делаем простую форму сообщения с URL-адресом
, который является обратным поиском представления с именем входа.
Затем мы помещаем токен CSRF, а затем принимаем форму,
и я просто делаю это с тегами абзаца.
Так что это простой логин,
это не тот, который мы показываем.
Затем следующее - скрытое значение, которое вы должны передать,
чтобы, когда вы действительно успешно вошли в систему,
он знал, что вернется к автомобилям.
Когда все это будет сделано, он вернется
сюда после того, как вход был выполнен.
Чтобы регистрация/логин,
вы можете поместить это в любое из своих приложений,
но вы хотите назвать его registration/login.html.
Поэтому, если я смотрю очень быстро,
и я иду в дома/шаблоны,
это все шаблоны.
Когда я делаю ls, вы увидите, что у меня
есть дом/шаблоны/дом и дом/шаблоны/регистрация.
Здесь может быть несколько папок.
Если я посмотрю на то, что находится в регистрации,
вы увидите, что у меня есть этот простой логин, а затем
более сложный логин, который даст нам
возможности входа в GitHub.
Так что это означает, что логин использует социальные сети.
Суть в том, что под этими шаблонами,
вам не нужно иметь только одну вложенную папку,
вы можете иметь более одной вложенной папки.
Так что это необходимая конфигурация, чтобы сделать ее так
, чтобы, когда мы сообщаем нашим представлениям, чтобы добавить логин mixin,
который мы увидим всего за секунду.
Мы сообщаем нашим представлениям в логине, чтобы использовать логин mixin,
тогда он знает, откуда получить шаблон.
Так что это лишь часть этого, и
ваши инструкции подскажут вам, как это сделать.
Таким образом, любое приложение, которое вы собираетесь
построить, или любой проект, который вы собираетесь построить,
вы должны поместить их в настройки py
, urls.py, а затем сделать шаблон.
Затем вы должны начать использовать
логин mixin, а затем все
волшебным образом начинает собираться вместе.
Итак, давайте посмотрим на фактическое приложение авто.
Мы рассмотрим пару разных вещей
здесь, авто/URL-адреса.
Я собираюсь сделать многотерминальную вкладку,
поэтому я могу переключаться между файлами очень быстро.
Вероятно, у тебя есть редактор текста лучше меня.
Итак, у меня есть URL-адреса,
я собираюсь взглянуть на autos/views.py.
Затем я собираюсь посмотреть на autos/model.py.
Затем я собираюсь посмотреть на autos/forms.py.
Итак, давайте проработаем эти четыре файла,
URL-адреса, представления, модели, формы.
Возможно, давайте сначала сделаем модели.
Так что это довольно просто.
Мы собираемся сделать класс объектов Make.
Он будет иметь одно символьное поле
с некоторыми валидаторами в нем.
Мы играем с этим с помощью форм.
Вы можете поместить валидаторы в модели.
Мы ранее видели валидаторы в форме,
но есть валидатор, который в основном говорит, что
мы не будем принимать данные, поступающие в
эту таблицу базы данных, если только
нет по крайней мере двух символов.
Это _str_, ты уже давно этим занимаешься.
Это в основном, если вы берете
объект модели фактическую марку, и вы печатаете
его, он говорит, какие из полей,
в данном случае, есть только одно поле.
Так что просто говорит, когда мы преобразуем
объект модели в строку,
мы решаем, как это выглядит.
Затем у нас есть автомобиль, и у него
есть ник с MinLengthValidator, max_length 200,
и пробег, который имеет целочисленное поле, комментарии,
которое представляет собой поле 300 символов,
а затем внешний ключ в тоже.
Это как отношения «один ко многим» или «многие к одному»,
а не «многие ко многим», просто внешний ключ в Make.
Затем мы собираемся on_delete
CASCADE, что действительно означает, что если вы удалите Make,
то соответствующие автоматические записи
будут автоматически удалены.
Так что это довольно простая модель,
на самом деле очень, очень простая.
Еще раз, мы всегда определяем
этот _str_ (self), чтобы мы знали, что если вы
просто показываете его, как в
интерфейсе администратора, или если вы просто
печатаете его или просто
преобразуете саму модель
в строку, поле среди этих полей, которое
должно быть использовано, является ,
чтобы показать конечным пользователям.
Итак, это файл моделей.
Давайте посмотрим на файл форм дальше.
Таким образом, файл формы интересен,
потому что мы видели формы, которые
сами по себе являются формами,
но это особый вид
формы, а затем это ModelForm.
В этом, мы обычно в других моделях,
у нас были все эти поля,
и мы положили их в, и это выглядело
очень похоже на файл модели, где
у нас есть поле символов, PositiveIntegerField.
Но то, что мы в основном говорим, знаешь что?
Мы собираемся сделать форму здесь.
Действительно, все, что мы хотим сделать, это взять
все поля из
модели Make и сделать их поля формы.
Таким образом, форма и модель - это две разные вещи.
Форма - это то, что проходит
между представлением и шаблоном,
и, как вы увидите,
она также автоматически переходит в модели,
так что это точно так же, как сделать все поля.
Давайте сделаем форму, потому что
объекты формы не должны быть связаны с моделями.
Но в этом случае мы собираемся
вывести объект формы из модели.
Поэтому вместо расширения формы мы расширяем ModelForm.
Так что это должна иметь ModelForm,
и это лишь некоторые данные, которые говорят, что модель,
из которой мы собираемся вытащить все наши поля, - это модель Make,
и у нее есть только одна вещь, которая является именем.
Вот оно. Таким образом, это автоматическое
создание формы, которая, если
мы изменили ее и добавили другое поле здесь,
то эта форма make автоматически будет иметь поле.
Вы можете дать ему список полей,
_ все _ _ _ это
как сигнал, чтобы сказать: «Просто дайте мне все они».
Теперь могут быть некоторые внутренние
вещи, такие как созданные и
обновленные, или что-то, что вы не хотите использовать.
Так что это форма, помните, как работают формы.
Мы прикрываем это раньше. Давайте посмотрим на наши URL-адреса.
Теперь многое из этого выглядит
довольно похоже на то, что мы сделали.
У нас в основном есть основная таблица,
которая является нашей таблицей автомобилей,
и наша таблица поиска, которая является нашей таблице делает.
Тогда у нас
есть три вещи, есть основной вид списка,
который перечисляет все автомобили.
Существует основной вид списка Make,
в котором перечислены все марки.
Тогда мы можем сделать
новый, который не имеет первичного ключа,
потому что часть идей, которые
создают, создает новую вещь,
которая собирается генерировать первичный ключ.
Тогда у нас будет обновление и удаление.
Таким образом, у нас есть чтение, создание, обновление, удаление.
Так что это не совсем cred,
но вы видите все эти четыре вещи.
Таким образом, у нас есть представления,
и мы называем эти представления, чтобы мы могли
ссылаться на них в наших представлениях
сами и в нашем шаблоне,
чтобы мы могли создавать связи между ними.
Таким образом, они
довольно просты и не все такие разные.
Таким образом, веселье начинает происходить, когда мы находимся в views.py.
Поэтому login mixin,
если вы помните от автора z,
вы просто добавляете это в представление, и он просто в
основном говорит, что вы не можете добраться
до этого представления, если вы не вошли
в систему, и если вы не вошли в систему,
он столкнется с
файлом login.html, а затем отскочит после того, как вы сделано.
Таким образом, LoginRequiredMixin - это все, что нам нужно сделать.
Если вы пойдете к образцу автора z,
вы увидите, что я сделал это вручную.
Вы не хотите делать это вручную,
вы просто вызываете логин mixin.
Теперь, так что это основное представление представляет собой список,
и давайте
посмотрим на то, как это будет выглядеть.
Это представление списка.
Таким образом, мы собираемся провести сколько бы аудитов у нас ни было,
мы собираемся перебирать этот список,
мы собираемся получить все аудиты из базы данных.
Затем мы собираемся добавить автоссылку,
затем представление, которое делает ссылку с
подсчетом, сколько делает есть и добавить марку.
Поэтому позвольте мне также перейти в шаблоны автомашин
, снова авто и список автомашин.
Так что это шаблон, который делает это.
Есть несколько вещей, которые мы получаем,
мы получаем автосписок.
Теперь имена этих не навязываются вам,
но есть соглашения, которые выйдут через мгновение,
мы будем выглядеть действительно полезными.
Так что мы получим автосписок.
Если мы вернемся в наши представления,
мы видим, что мы говорим,
получить все объекты из автоматической таблицы,
все объекты автокласса извлекают их все,
мимо них в контекст как auto_list.
Теперь мы также хотим, чтобы иметь возможность
показать, что маленький счетчик, это номер два,
поэтому мы собираемся спросить,
идти вперед к созданию объектов
все, но не давать мне список из них,
считать их и дать мне номер.
Таким образом, make count застрял там, и вы
увидите, если может рассчитывать больше нуля.
Мы можем показать объявление и кнопку авто,
а также где-то показывает количество
марок, просмотреть все марки, добавить марку,
и счетчик марок выходит здесь.
Так что это еще одна вещь, которую мы положили.
Автоматический список, который мы собираемся пройти, и эта
переменная итерации авто будет
проходить через каждую из отдельных вещей,
и ник, make и т. Д.,
Это прямо из файла models.py.
Есть четыре вещи, которые есть у каждого авто,
и мы просто распечатываем все это.
Вы также получаете первичный ключ,
и поэтому мы собираемся сделать URL-адрес обновления,
и этот URL-адрес является autos: auto_update.
Поэтому, если вы посмотрите в urls.py,
мы видим,
что это автоматическое обновление ищет, это дает нам путь к представлению, но этот конкретный путь нуждается в
одном параметре, который является первичным ключом,
и поэтому это означает, что этот тег шаблона URL,
autos должен иметь auto.id. через модели,
у вас есть один, и вы делаете auto_create,
это довольно прямо вперед.
Но одно из правил заключается в том, что вы должны иметь
хотя бы один make, прежде чем вы
сможете сделать авто, потому что, если вы помните, добавьте авто, чтобы этот выпадающий список был популярен, и
это вытаскивается из таблицы make,
и это в основном путь вокруг этого.
Это главный вид.
Вот мы идем, обновление.
Это вид авто, и тогда, если мы сделаем вид make,
мы делаем то же самое.
Если мы пойдем и посмотрим на список марок,
мы делаем то же самое основное,
просматриваем все марки,
и теперь мы получили обновление и удаление.
Таким образом, вам не нужно считать.
Мы просто хотим захватить все объекты,
мы хотим поместить его в контекст под список make,
а затем мы делаем список на HTML,
и это еще проще.
Он просто проходит через список make,
он приходит через контекст.
Если их нет, мы не распечатаем это,
а затем мы выписываем его имя,
а затем у нас есть обновление и кнопка удаления,
которая переходит к обновлению и удалению,
и, конечно же, если вы посмотрите в urls.py,
те также обновления и удаления
имеют требования к первичному ключу,
и поэтому у вас есть первичный ключ
, который вы должны передать здесь,
чтобы сделать этот URL-адрес правильным URL-адресом,
а затем просто некоторые ссылки,
чтобы вернуться к различным вещам, чтобы
мы могли вернуться к автомобилям,
просматривать делает, добавить новую марку.
А теперь, отмените все эти вещи.
Таким образом, это views.py
для перечисления автомобилей и марок.
Теперь мы хотим сделать вид создания.
Поэтому, если мы посмотрим на представление make create,
то есть добавить make.
Это создаст эту форму.
Я могу сделать это больше здесь.
Он может создать такую форму,
где мы собираемся положить в штуку под названием Chevy.
Поэтому нам нужен способ сделать эту форму.
Мы собираемся сделать его обязательным для входа,
мы не позволим людям сделать это.
Мы собираемся иметь некоторые переменные, которые являются широким классом,
например, какой шаблон мы хотим использовать,
и success_url после того, как мы сделали это правильно.
Теперь, если вы просто подадите
его, и он жалуется, он этого не сделает.
Но как только вы сделаете это правильно,
куда вы хотите пойти после этого?
Итак, Шевроле, куда ты хочешь пойти?
Это функция контроллера.
Я хочу вернуться к автоматическому списку,
и поэтому
success_url переходит к автосам: все, что в urls.py является основным видом.
Это имя основного представления,
и поэтому, если мы идем сюда,
какой шаблон использовать и какой success_url.
Если мы сделаем запрос на получение,
мы собираемся построить форму для
make, которая исходит из формы make,
но на самом деле она исходит из модели make,
которая является только одним строковым полем.
Так же просто. Мы используем это повторно.
Мы просто говорим, давайте сделаем форму,
которая тянет отсюда.
Мы должны передать форму,
потому что модели не могут быть использованы для создания этого экрана.
Этот экран исходит из формы.
Хорошо. Если мы посмотрим на шаблон,
если мы посмотрим на make создать
шаблон или сделать форму.
Так что это шаблон, который мы собираемся использовать для создания формы.
Нам понадобится form_as_table.
Так вот, как мы делали формы.
Поместите токен CSRF,
вы создаете таблицу,
которая может быть как абзацы или как таблицы.
Но что бы то ни было, вам нужен этот объект формы.
Поэтому вам нужно передать объект формы в.
Итак, вот мы, мы собираемся сделать форму,
а затем мы идем к объекту формы в,
а затем мы собираемся визуализировать self.template
autos.makeform html.
Тогда мы вернем это для получения.
Затем, когда мы нажимаем
кнопку отправки, Добавить сделать,
мы нажимаем кнопку отправки,
он приходит в сообщение,
потому что мы сделали сообщение формы, приходит.
Не делай этого. Это ужасно.
Ненавижу, когда Vi это делает.
Но вот мы идем, мы вернулись.
Да. Таким образом, сообщение приходит,
Request.post имеет все пары ключевых значений
, которые являются этими парами ключ-значение, как определено формой.
Итак, мы говорим, давайте сделаем форму с
исходными данными, поступающими из сообщения запроса.
Учитывая, что форма сгенерировала
ее, она знает, каковы имена этих полей,
и это то, что скрывается за тем, как формы работают.
Но он также проверяет, являются ли данные формы действительными, и это
означает, что мы все эти правила валидатора соблюдаются.
Если правила валидатора не соблюдаются,
если не форма действительна,
мы просто собираемся отправить его обратно.
Таким образом, этот код здесь,
эта форма не является допустимым кодом.
Если я поставлю одну букву A и
нажму «Submit», он вернется и повторно отобразит
форму и все эти ошибки,
все эти вещи обрабатываются этим кодом формы,
этот код формы Django выясняет, что не так.
Скоро немного, чтобы я мог
вернуться к этому быстрее. Там мы идем.
Он выясняет, что с ним не так,
делает сообщение об ошибке,
сообщение об ошибке пришло из models.py прямо здесь.
Нет, прямо здесь.
Затем прошел через forms.py, потому что это
форма, в конечном счете, которую мы унаследовали от
формы модели. Получил его?
Так что это круто. Так что это условие ошибки,
а в противном случае мы делаем form.save.
Теперь дело здесь, что действительно супер
круто, потому что эта форма
является формой модели, и
имена полей такие же, как
имена полей в модели,
и поэтому она фактически экономит на самой модели.
Таким образом, форма содержит данные модели
, которые пришли из почтового запроса, а затем сохраняет его.
Это сохраняет форму.
Он помещает его, а затем мы просто
перенаправляем обратно на URL-адрес запроса.
Это довольно лаконично.
Мы вытаскиваем старые данные сообщения,
мы проверяем, если это плохо, если это плохо,
мы отправляем форму обратно в
тот же шаблон, который мы
сделали, а затем мы сохраняем его, если это хорошо,
а затем мы попадаем в URL-адрес успеха.
Это прекрасная вещь.
Но так же, как и в Django все время,
это гораздо более словесная вещь,
хотя это супер лаконично.
Если бы вы сделали это практически на любом другом языке,
вы бы были как 75 строк кода,
и здесь у нас есть около 15 строк кода.
Но оказывается, что в Джанго
почти всегда есть более лаконичный способ сделать это.
У нас есть общий вид создания.
Вы можете взглянуть на документацию для
этого общего представления создания django.views.generic.edit.
Давай просто пойдем и погуглим эту штуку.
Я всегда просто помещаю точку здесь, и это обычно
дает мне право
, потому что это фактический пакет и класс внутри
пакета. О, нет.
Извини. Вы думали, что это доменное имя,
так что поиск не сработал.
Но теперь я просто скажу Django,
что-то, поэтому, по крайней мере,
это будет делать с поиском для меня,
общие представления редактирования переходят к CreateView.
Таким образом, вы можете прочитать все это,
общий CreateView на самом деле.
У меня есть ссылка на это?
Так вот, ты идешь. Взгляни на это.
Теперь, это, как
и некоторые другие взгляды, которые мы унаследовали,
имеют тонну функциональности в них.
Поэтому, если я хочу сделать автосоздание,
это все, что требуется.
Теперь, AutoCreate и MakeCreate
для всех намерений и целей,
сделайте то же самое.
Итак, что происходит в AutoCreate,
потому что мы
расширяем CreateView, у нас есть три бита метаданных,
мы говорим ему, какую модель мы хотим использовать,
какие поля из этой модели мы хотим,
и где URL-адрес успеха идти.
Затем это генерирует весь этот код.
Мы унаследовали весь этот код.
Вы заметите, что
здесь нет ничего жестко закодированного, кроме MakeForm.
Теперь нам даже не нужно создавать форму для Auto,
потому что этот код прямо здесь строит форму.
Не только это, но он использует это имя
Auto, чтобы выбрать шаблон.
Поэтому, если я сделаю auto_form,
я должен использовать это.
Я использую это, это мой базовый бутстрап.
Не беспокойся об этом слишком.
Таким образом, он знает
имя шаблона, который он будет использовать.
Мне нужно только сказать, какой шаблон использовать здесь,
потому что он получает шаблон,
auto_form.html - это шаблон.
Довольно круто. Довольно круто и круто.
Таким образом, он автоматически находит это и success_url.
Так что это все, что нужно.
Фактически, в этом MakeCreate
я мог бы удалить весь этот код отсюда до сюда,
но вместо этого просто сделать CreateView, расширив CreateView.
Я просто показываю вам это, потому что хочу, чтобы вы
увидели, что на самом деле происходит.
Но это не то, как вы пишете свой код.
Вот как вы пишете свой код.
Итак, теперь я хочу показать вам
трудный способ сделать обновление.
Итак, что такое обновление? Давайте взглянем на код.
Итак, давайте посмотрим на вид делает.
Обновление - это то, что
происходит, когда мы идем сюда
, и это будет идти в MakeUpdate.
Итак, вот MakeUpdate, вот urls.py. Это вот эта.
Я имею в виду, найдите обновление первичного ключа,
которое тогда, если вы посмотрите здесь,
это будет автопоиск одного обновления.
Так что я собираюсь обновить «Шевроле».
Он должен прочитать старые данные,
должен показать его вам,
а затем позволить нам обновить его, а затем отправить его, проверяя,
конечно, на любые ошибки проверки.
Затем перенаправляя нас обратно на success_url.
Поэтому, если мы посмотрим на взгляды,
мы собираемся снова,
предвидеть, есть гораздо более простой способ сделать это.
Поэтому мы устанавливаем эти переменные или success_url,
какой шаблон мы хотим, и модель.
Тогда у нас есть запрос на получение.
Потому что в urls.py есть это int:pk,
были переданы в этом значении pk.
Теперь этот get_object_or_404 действительно круто.
Это get_object_or_404 (self.model pk=pk).
Вот этот параметр, который мы передаем
pk равно, и обычно они имеют одинаковое имя,
но это параметр get_object_or_404.
Этот второй параметр является параметром
, который был вызван для нашего get.
Self.Model, конечно, это сделать.
Get_object_or_404 в основном проверяет, если,
я сделаю это обновление,
давайте перейдем к make, давайте сделаем обновление.
То, что он делает, это принимает этот номер,
это три здесь, autos/lookup/3/update,
и он извлекает старые данные.
Теперь, что произойдет, если
у меня случайно есть номер
, который не существует в базе данных,
например 9,999, и я делаю запрос на получение этого?
Я получаю «Страница не найдена 404».
То, что происходит здесь, так это то, что вы говорите: «Эй,
загрузите этот объект и дайте его мне и переменной
, сделайте, или просто взорвите и отправьте ошибку 404».
Таким образом, это говорит вам, что происходит,
что вы видите просто: «No Make соответствует заданному запросу».
Теперь, как правило, вы не должны печатать их.
Три он работает, и поэтому он не взрывается.
Поэтому get_object_or_404 - это способ загрузки
старых данных
, а затем защиты с помощью этих данных или просто взорвать.
Так что не идти дальше в этот момент.
Теперь мы создадим
форму и заполним ее старыми данными.
Итак, экземпляр, что делает экземпляр.
Так вот и есть объект.
Сделайте MakeForm. Вот MakeForm.
Все поля модели
наследуются от модели Make.
Затем передайте его в шаблон make_form.html,
который мы только что посмотрели.
Эта форма приходит, это все, что нам нужно.
Это очень общий вид.
На самом деле это не так уж и важно.
Все это в значительной степени закодировано в этой форме,
которая получена из модели.
Тогда, конечно, мы набираем кучу вещей
и нажимаем «Отправить».
Он делает точно то же самое, что и Create,
и что он делает хорошо.
Сначала он должен сделать get или 404, потому что
мы отправляем в вещь с первичным ключом.
Мы загружаем его, чтобы убедиться, что у нас есть объект для обновления.
Затем мы создаем новую форму make
из этой базы данных, а затем изменим ее.
Таким образом, это похоже на начальные данные,
но затем он изменяет их на данные.
Таким образом, в этом конкретном случае
Chevrolet является старым значением в базе данных.
Если я скажу Боути,
запросить пост-лабораторию Боути,
это запустит Chevrolet, но в этой форме
объект, то это будет Боути.
Конечно, если это недействительно,
мы вернем сообщение об ошибке прямо здесь.
Если это действительно, мы
его сохраним, и этот новый Боути
будет сохранен там.
Поэтому, если мы рассмотрим наши делает,
мы видим, что это теперь Bowtie,
и мы собираемся перенаправить на URL-адрес успеха.
Сейчас,
я надеюсь, вы сможете
предсказать, что будет дальше.
AutoUpdate, расширяет представление обновления,
общее представление редактирования.
Он говорит, какая модель это,
какие поля вы хотите, и
куда идти, когда это успешно.
Тогда он делает все, что здесь.
Буквально, я мог бы пойти и сказать
точно такие же слова для make delete,
что происходит, когда вы идете сюда,
и вы удаляете, а затем у вас
есть отмена, есть подтверждение удаления.
Имя этого шаблона не выбирается случайным образом,
его нужно назвать confirm.delete,
модель confirm.delete.
Вот ты идешь. У тебя есть токен CSRF.
Вам вручили марку как объект в этом.
Таким образом, что производит этот вывод.
В этом нет ни одной формы.
Есть только мака, которая загружается
объектом или 404, а затем она проходит и визуализирует его.
Затем, когда сообщение происходит, он извлекает его.
Если он там, 404 снова
проверяет плохие данные и удаляет их,
а затем прыгает на URL-адрес успеха.
Не требуется много, чтобы угадать, что я собираюсь делать дальше,
и то есть, если вы расширяете представление удаления,
вы получаете весь этот код бесплатно.
Вы просто говорите, какие поля модели
и куда идти для успеха.
Главное в том, что
как вы делаете домашнее задание,
я уверен, что некоторые из вас просто скопируют и
вставят все эти вещи. Это неправильно.
MakeCreate, MakeUpdate и
MakeDelete должны быть
такими же короткими, как автосоздание, автообновление и автоудаление.
Потому что вы собираетесь делать эти общие
представления редактирования много, и
мы будем делать CRUD снова и снова,
и вы действительно не хотите писать 15 строк кода.
Это ненужное повторение, ненужная резка и
вставка и изменение кода, если
вы можете сохранить его очень простым.
Поэтому я могу в основном создать полный набор
форм CRUD и функциональность CRUD с
проверкой для модели с
этим кодом, а затем мне даже не нужно иметь forms.py, у
меня просто есть models.py.
Поэтому, если вы делаете свои Autos,
вы думаете, что я совершил
ошибку, если я делаю forms.py.
Потому что, если я просто использую этот views.py таким образом,
вместо того, чтобы сделать все из них похожими на MakeUpdate,
вы сэкономите себе много
времени и энергии, и мы должны изменить эти вещи.
Намного проще найти
все изменения, а затем изменить их.
Таким образом, это проход образца кода для Autos.
Ты сделаешь задание на это,
но не копируй все.
Я установил это так, чтобы
время, которое вы тратите на понимание того, что происходит,
особенно в представлениях.
URL - это ваша гордость, просто
копируйте, модели,
которые вы просто копируете, URL-адреса, которые вы просто копируете,
но представления не просто копируют его,
выясняют, что на самом деле происходит,
и придумывают более простой и более лаконичный способ сделать все это. В
этот
момент Django начинает выглядеть очень красиво.
Поэтому я надеюсь, что вы нашли это полезным. Ура.