Docker 4. Взаимодействие с контейнером PostgreSQL

Контейнер запустили, теперь давайте научимся с ним взаимодействовать.

Самый прямой способ взаимодействия, это зайти в контейнер и подключиться к CLI(Command Line Interface) PostgreSQL. Проще говоря, подключиться к БД в терминале.
Для этого необходимо в терминале выполнить следующую команду:

docker exec -it  <container-name> psql -U <dataBaseUserName> <dataBaseName>

Для варианта запуска, показанного в прошлом посте, строка будет выглядеть так:

docker exec -it  postgres-db psql -U username testdb

Подробнее про каждый пункт:
- docker exec - комманда позволяющая зайти в контейнер и выполнить указанную далее команду.
- -it - параметр, сообщающий докеру, что мы хотим подключиться в интерактивном режиме. Бывают случаи, когда терминал занят другим приложением, например выводом запущенного бота и чтобы выйти из контейнера не завершая работу запущенного приложения, необходимо нажать сочетание клавиш CTRL+Q+CTRL+P
- <container-name> - имя или идентификатор контейнера, к которому хотим подключиться
- psql - команда для выполнения в контейнере. В нашем случае это подключение к PostgreSQL в консоли.
- -U <dataBaseUserName> <dataBaseName> - параметры предыдущей команды. Тут мы передаём флаг -U, указывающий, что далее будет введено имя пользователя для авторизации и имя базы данных к которой необходимо подключиться.

В итоге команда должна выглядеть следующим образом:

docker exec -it postgres-db psql -U username testdb

Так, мы попадём в консольный интерфейс PostgreSQL. Можно работать с БД.
Для выхода достаточно ввести команду exit.

Другой способ подключиться к БД, это использовать менеджеры баз данных.
Таких программ много, например PgAdmin, DBeaver и другие.
Установив любой менеджер поддерживающий PostgreSQL, для подключения к БД необходимо указать следующие данные:
- host: localhost
- port: 5432
- username: username
- password: password
- database: testdb

Точно так же, можно использовать запущенную БД в наших проектах, например в Django:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': testdb,
        'USER': username,
        'PASSWORD': password,
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

На этом всё. Если возникнут вопросы по данной теме, не стесняйтесь задавать их в комментариях, обязательно постараюсь ответить.

Файлы к посту, можно получить в боте по коду: 684611
Пост на сайте.
Поддержать канал.

#docker #postgresql #postgres #sql #контейнер

Django 5. Инициализация приложения блога

Я не просто так назвал данный пост "Инициализация приложения блога". В Django, проектом считается сам установленный и инициализированный Django. Этим мы занимались во втором посте. А вот страницы сайта или отдельные модули называются приложениями. Именно созданием приложения мы займемся сегодня.

Для создания приложения необходимо в терминале выполнить команду: python manage.py startapp blog. Убедитесь, что в терминале вы находитесь в той же директории, что и файл manage.py. В дальнейшем я не буду заострять на этом внимание.
В папке с проектом появилась директория blog с набором пустых файлов приложения.

Пройдёмся по основным файлам приложения:
- Файл admin.py - в данном файле будем указывать всё, что непосредственно связано с панелью администратора. В основном, это регистрация моделей.
- Папка migrations - в ней будут собираться файлы с описаниями миграций базы данных, относящихся именно к приложению.
- Файл models.py - в данном файле будем описывать модели и менеджеров базы данных.
- Файл views.py - в данном файле описываются представления соответствующие страницам на сайте.
- В дальнейшем будут созданы и другие файлы разной функциональной направленности.

Приложение создано, но ещё не активировано. Для активации необходимо вернуться в файл settings.py и в параметр INSTALLED_APPS добавить строку с указанием конфигурации приложения.

INSTALLED_APPS = [
    # Содержимое списка
    # ...
    'blog.apps.BlogConfig',
]

Как мы получили данную строку?
Первый параметр blog - название приложения, указанное при его создании.
Второй параметр apps - указание на файл apps.py в директории приложения.
Третий параметр BlogConfig - указание на класс BlogConfig в упомянутом ранее файле.

Далее принято делать модели базы данных, но я несколько отойду от принятого. В следующем посте сделаем заготовку для главной страницы, она же, по началу будет выступать в роли заглушки сайта.

Файлы к посту, можно получить в боте по коду: 966714
Пост на сайте.
Поддержать канал.

#django #python #приложение

Django 6. Базовый шаблон

Сегодня мы создадим базовый шаблон. В базовый шаблон прописывается то, что должно быть на всех страницах сайта. Подключаются все необходимые файлы стилей и скриптов, прописываются мета-теги.

Для создания шаблона, мы будем использовать CSS-фреймворк Bootstrap5.
Давайте его скачаем. Нам нужен CSS-файл и JS-файл.
CSS: https://bootswatch.com/5/lumen/bootstrap.css
JS: https://raw.githubusercontent.com/twbs/bootstrap/v5.3.0/dist/js/bootstrap.bundle.js
Если у вас в браузере, файл не скачивается, а открылся для просмотра, просто нажмите сочетание клавиш CTRL+S

В директории приложения blog создаём папку static, а в ней ещё две папки css и js.
Помещаем скачанные файлы в соответствующие папки в директории static.

В директории приложения blog, создаём папку templates, а в ней папку с названием приложения, то есть, тоже blog.
Должна получиться такая иерархия <проект>/blog/templates/blog. Если вы использовали иное название для приложения, то замените `blog`, на соответствующее.

Директория blog в папке templates, это место, где будут храниться шаблоны связанные с приложением blog. Создадим там файл base.html со следующим содержимым:

{% load static %}
<!DOCTYPE html>
<html lang="ru" data-bs-theme="dark" class="h-100">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Press Any Button</title>
    <link href="{% static "css/bootstrap.css" %}" rel="stylesheet">
</head>
<body class="d-flex flex-column h-100">
<section class="al mt-3">
    <div class="container justify-content-center">
        <div class="alert alert-dismissible alert-warning">
            <h4 class="alert-heading">Приветствую вас!</h4>
            <h5 class="mb-0">Сайт находится в процессе разработки.<br>
                Следить за процессом разработки и повторять действия, можно в <a href="https://t.iss.one/press_any_button">Telegram-канале
                    "Код на салфетке"</a></h5>
        </div>
    </div>
</section>
<script src="{% static "js/bootstrap.bundle.js" %}"></script>
</body>
</html>

Как видим, используется обычная HTML-разметка, с добавление специальных Django-тегов.
Тэг {% load static %} сообщает Django, что в шаблоне используются статические файлы из папки static.
В месте, где мы подключаем CSS и JS файлы, используется тег {% static "путь_до_файла_в_папке_static" %}

Это будет наш базовый шаблон. В последствии мы его модернизируем и от него будут наследоваться шаблоны других страниц. В следующем посте, пропишем представление для него и добавим маршрутизацию URL-адресов и протестируем.

Файлы к посту, можно получить в боте по коду: 153069
Пост на сайте.
Поддержать канал.

#django #python #шаблон #базовый_шаблон #html #css #bootstrap

Django 7. Первое представление

В интернете всё построено на запросах. Открывая любую страницу, мы делаем запрос к серверу "хочу попасть на такую-то страницу", а сервер уже обрабатывает его и возвращает ответ на запрос с содержимым страницы.
Для формирования ответа на запрос с доступом к той или иной странице в Django отвечают, так называемые "представления", они же "views".
Давайте создадим наше первое простое представление, для возврата содержимого базового шаблона посетителю сайта.

Переходим в файл views.py расположенный в директории приложения.
Под имеющимся в файле импортом добавим функцию со следующим кодом:

def index(request):
    return render(request,
                  'blog/base.html')

Мы создали представление index, получающего запрос от пользователя.
Поскольку у нас пока заглушка и данные передавать нам никакие не нужно, сразу переходим к возврату ответа пользователю. За это отвечает функция render, в которую мы передаём запрос, а так же путь до файла шаблона.

Теперь получив запрос на отображение главной страницы сайта, Django вернёт её содержимое. Только вот Django, пока ничего не знает, о том, где у нас главная страница и как строить маршрутизацию по URL-адресам.

В директории приложения создадим файл urls.py.
Файл urls.py в Django имеет важное значение. Он определяет, как URL-запросы будут соотноситься с определенными представлениями и функциями. В этом файле определяются URL-шаблоны, которые связывают входящие URL-запросы с соответствующими представлениями. Представления обрабатывают запросы и возвращают соответствующие HTTP-ответы.

Добавим следующий код:

from django.urls import path

from blog import views

app_name = 'blog'
urlpatterns = [
    path('', views.index, name='index'),
]

В переменной app_name указываем имя приложения, для корректного сопоставления URL-адресов.
В переменную urlpatterns присваиваем список. Внутри списка вфзфывем функцию path, формирующую маршрут и URL-адрес.
В неё передаём:
- Первым параметром URL-паттерн. Пустые кавычки означают, что паттерн будет применён к основному адресу сайта, например pressanybutton.ru, а если пропишем "blog", тогда он будет срабатывать, когда будем переходить по адресу pressanybutton.ru/blog
- Вторым параметром указываем, какое представление необходимо вызвать при запросе данного адреса.
- В третьем параметре указываем имя для пути.
Также обратите внимание на вторую строку импорта, замените blog на имя вашего приложения

Теперь, надо сообщить Django о том, что у нас есть приложение со своим набором URL-паттернов. Для этого, перейдём в директорию проекта и откроем файл urls.py.
Там уже будет переменная urlpatterns с прописанным паттерном панели администратора.
Добавим в имеющийся список новую строку с адресами приложения:

from django.urls import path, include

urlpatterns = [
  # ...
    path('', include('blog.urls', namespace='blog')),
]

В данной строке, мы сообщаем Django, что по пути сайта мы будем использовать URL-паттерны из приложения.

И сразу добавим сюда определение путей для медиа и статических файлов. В этом же файле, только ниже добавьте следующие строки:

from django.conf.urls.static import static  
from django.conf import settings

urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)  
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Запустим Django командой python manage.py runserver и перейдём на страницу.
Должна отобразиться страница с заглушкой. Такая-же как https://pressanybutton.ru

В следующем посте, начнём делать структуру Telegram-бота

Файлы к посту, можно получить в боте по коду: 772660
Пост на сайте.
Поддержать канал.

#django #python #представление #views #render #url_паттерны

AIOgram3 5.1. Создание структуры

Большинство проектов не ограничиваются одним лишь файлом main.py, напротив, часто проекты состоят из множества файлов с кодом конкретной логики. Для этого в Python предусмотрена "пакетная" система. Пакет является директорией, которая содержит в себе модули и подпакеты. Он позволяет логически объединять связанный функционал и предоставляет простой способ управления зависимостями и кодом в рамках проекта.

Создадим основной пакет botlogic со всей будущей логикой.
Если, вы работаете в PyCharm или другой Python-направленной IDE, то достаточно в контекстном меню директории выбрать "New - Python Package".
Но создать пакет можно и вручную.
Для этого необходимо создать директорию с необходимым именем пакета. Внутри директории создать пустой файл __init__.py. Данный файл сообщит интерпретатору, что директория является пакетом.
При каждом создании пакета, необходимо создавать внутри пустой файл __init__.py

В этом пакете создадим файл settings.py.
В этом файле будут располагаться, при необходимости, настройки бота. Пока, что мы перенесём в него токен бота и добавим ID администратора.

Тут, для удобства применим ООП.
Те, кто уже успели испугаться, расслабьтесь, в создании бота ООП либо крайне мало, либо нет вовсе. Тут я применяю его банально для удобства.

Создадим дата-класс Secrets и в нём два поля token и admin_id:

from dataclasses import dataclass


@dataclass
class Secrets:
    token: str = 'ваш_токен'
    admin_id: int = 12345

Разберём, что тут происходит.
Мы создали класс Secrets и определили два поля:
- Строковое token в котором указываем полученный от BotFather токен бота.
- Целочисленное admin_id в котором необходимо указать ваш Telegram-ID, но это будет несколькими постами далее, пока просто заполните любым числом.

Далее должно было быть несколько методов, таких как __init__ и геттеры полей, но нам тут всё это не нужно. Для избегания большого количества кода, мы используем декоратор @dataclass.
Декоратор @dataclass - позволяет автоматически сгенерировать методы класса для работы с данными.
Когда применяется декоратор @dataclass к классу, он автоматически добавляет реализацию необходимых методов, таких как:
1. __init__: Создает конструктор класса, принимающий значения для каждого атрибута.
2. __repr__: Создает строковое представление объекта, которое используется при вызове repr().
И ряда других.
Кроме того, декоратор @dataclass позволяет использовать аннотации типов для объявления типов полей класса, что упрощает чтение кода.

Продолжение в следующем посте.

Файлы к посту, можно получить в боте по коду: 488659
Пост на сайте.
Поддержать канал.

#aiogram #python #python_package #структура #dataclass

AIOgram3 5.2. Создание структуры, продолжение

Не уходя из файла settings.py
Перенесём сюда инициализацию бота, а именно строку и сразу заменим содержимое на получение данных из класса Secrets:

from aiogram import Bot

bot = Bot(token=Secrets.token)

Таким образом, мы сможем обращаться к экземпляру бота не только из главного файла.

С файлом settings.py мы пока закончили.
Перейдём в файл main.py и изменим импорты.
Было:

from aiogram import Bot, Dispatcher

Поменяем на:

from aiogram import Dispatcher  
  
from botlogic.settings import bot

Как вы помните, при запуске бота, не понятно, запустился он или нет, поскольку в терминале не было никаких данных. Давайте это исправим, добавив базовый логгер.
Перед переменной dp добавляем пустую строку и вставляем туда код логгера, а в начло файла добавляем строку импорта:

import logging

logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s - [%(levelname)s] -  %(name)s - (%(filename)s).%(funcName)s(%(lineno)d) - %(message)s"
    )

При запуске бота, будет инициализироваться метод basicConfig из втроенной библиотеки logging. В него мы передаём два параметра:
- level - определяющий уровень выводимой информации. Основные уровни информирования: DEBUG, INFO, WARNING, ERROR.
- format - определяющий формат выводимой информации.
С уровнем логирования всё понятно, он будет выводить данные уровня INFO, то о переменных в формате стоит рассказать подробнее.
Строка лога состоит из 7ми переменных:
- %(asctime)s — заменяется на текущее время в формате "год-месяц-день час:минута:секунда";
- %(levelname)s — заменяется на уровень важности лога, в нашем случае INFO;
- %(name)s — заменяется на имя логгера, который записывает сообщение;
- %(filename)s — заменяется на имя файла, в котором была вызвана функция логирования;
- %(funcName)s — заменяется на имя функции, в которой была вызвана функция логирования;
- %(lineno)d — заменяется на номер строки, в которой была вызвана функция логирования;
- %(message)s — заменяется на текст сообщения, переданного для записи в лог.

В следующем посте, продолжим формировать структуру и сделаем оповещение администратора о запуске или остановке бота.

Файлы к посту, можно получить в боте по коду: 488659
Пост на сайте.
Поддержать канал.

#aiogram #python #python_package #структура #logging

AIOgram3 6. Информирование администратора

Теперь давайте добавим функционал информирование админа бота о его запуске или остановке.

Перейдём в файл settings.py и в поле admin_id в классе Secrets пропишем ваш Telegram-ID. Получить его можно у бота https://t.iss.one/getmyid_bot

В пакете botlogic создадим новый пакет handlers.
Напоминаю, что пакет можно создать средствами IDE, выбрав создать новый Python Package или создать вручную, создав директорию и в ней пустой файл __init__.py.
В нём у нас будут находится обработчики сообщений пользователей, команд или различных событий.

В пакете handlers создадим файл events.py. В данном файле, будут находиться обработчики событий. Сейчас мы напишем два обработчика реагирующих на событие запуска и остановки бота.

from botlogic.settings import bot, Secrets


async def start_bot():
    await bot.send_message(Secrets.admin_id, 'Бот запущен')


async def stop_bot():
    await bot.send_message(Secrets.admin_id, 'Бот остановлен')

Мы создали две асинхронные функции start_bot и stop_bot. В теле функции вызвали метод send_message из экземпляра класса Bot. В метод первым параметром передаётся Telegram-ID получателя, а вторым текст сообщения.
Однако, вот так оставлять текст в функции не правильно. В случае, если надо будет изменить текст, в его поисках придётся перелопатить часть файлов бота. По этому, давайте создадим единый файл, в котором будем хранить все текстовые сообщения.

В пакете botlogic создадим файл views.py.
И создадим две функции start_bot_msg и start_bot_msg:

def start_bot_msg():
    return 'Бот запущен'

def stop_bot_msg():
    return 'Бот остановлен'

Две простейшие функции, возвращающее текст при вызове. Изменим наши функции в файле events.py, что бы они получали строки из только что созданных функций:

from botlogic.settings import bot, Secrets
from botlogic.views import start_bot_msg, stop_bot_msg


async def start_bot():
    await bot.send_message(Secrets.admin_id, start_bot_msg())


async def stop_bot():
    await bot.send_message(Secrets.admin_id, stop_bot_msg())

Осталось только зарегистрировать данные события.
Переходим в файл main.py и в функции start(), под вызовом диспетчера прописываем следующие строки:

from botlogic.handlers.events import start_bot, stop_bot

  dp.startup.register(start_bot)
    dp.shutdown.register(stop_bot)

Это встроенные методы диспетчера. Зарегистрировав события, когда в блоке try-finally запустится бот, он автоматически вызовет нашу функцию start_bot() и мы получим уведомление от бота. С остановкой бота аналогично.

Запустим бота и убедимся, что уведомления приходят, а в терминале появился лог событий.

Файлы к посту, можно получить в боте по коду: 270319
Пост на сайте.
Поддержать канал.

#aiogram #python

Django 8. Первая модель

Для постов на сайте и бота выдающего архив с дополнительными материалами, нужен удобный способ хранения файлов. Для этого будем использовать модель в Django.

В Django модель - это класс, который определяет структуру и поведение данных в вашем приложении. Он представляет таблицу в базе данных, где каждое поле в модели соответствует столбцу в таблице.

Давайте создадим первую модель, которая в последствии будет расширена.
Откроем файл models.py в директории приложения и напишем класс PostFilesModel.

class PostFilesModel(models.Model):
    title = models.CharField(max_length=200,
                             verbose_name='Имя файла')
    file = models.FileField(upload_to='post_files/')
    code = models.IntegerField(default=0,
                               verbose_name='Код файла',
                               unique=True)
    download_count = models.IntegerField(default=0,
                                         verbose_name='Скачиваний')

    class Meta:
        verbose_name = 'Файл поста'
        verbose_name_plural = 'Файлы постов'

    def increment_download_count(self):
        self.download_count += 1
        self.save()

    def __str__(self):
        return self.title

Разберём написанное:
Мы создали класс PostFilesModel и унаследовали его от встроенного в Django класса Model.
В нём мы прописали четыре поля:
- title - поле типа CharField. В нём хранятся строки. Мы в него будем передавать имя файла. В параметрах поля определена максимальная длина max_length в 200 символов и передали имя поля verbose_name.
- file - поле типа FileField. Представляет собой возможность загружать файлы на сервер. В нём мы указали параметр upload_to указывающий куда будет загружаться файл. Это не полный путь! Все файлы будут загружаться в папку media, а указанный выше путь, это путь внутри папки media.
- code - поле типа IntegerField. В нём хранятся целочисленные значения. В данное поле будет прописываться цифровой код, по которому можно будет получить файл у бота.
- download_count - поле типа IntegerField. В нём будет вестись статистика по скачиваниям файла. Кроме упомянутого ранее параметра определяющего имя поля, также был передан параметр default, обозначающий значение по умолчанию для создаваемого объекта модели.

Далее создали внутренний класс Meta. В этом классе настраиваются различные параметры модели, такие как сортировка, указание на конкретную таблицу в БД, имя модели и множество других.
В нашем случае, мы передаём два параметра: Имя и Множественное имя модели.

Ниже определён метод increment_download_count. Данный метод при вызове будет увеличивать счётчик загрузок на единицу.

И последний метод представляет переопределение метода __str__, возвращающего текстового представления поля title.

Применим изменения вызвав создание миграций и саму миграцию, выполнив две команды в терминале:

python manage.py makemigrations
python manage.py migrate

В следующем посте добавим модель в панель администратора и протестируем.

Файлы к посту, можно получить в боте по коду: 225028
Пост на сайте.
Поддержать канал.

#django #python #модели #миграции

Django 9. Регистрация модели

Для того, что бы можно было взаимодействовать с моделью, а именно добавлять, изменять или редактировать объекты из панели администратора, необходимо модель там зарегистрировать.

Откроем файл admin.py в директории приложения и создадим класс PostFilesAdmin унаследованный от Django-класса ModelAdmin.
И пропишем там три поля:
- list_display - со списком полей модели, значения которых необходимо отображать на странице модели. В нашем случае, это поля - название, код и количество загрузок.
- search_fields - определяет, по каким полям в модели будет происходить поиск.
- exclude - определяет поля, которые необходимо скрыть при создании объекта модели. В нашем случае это поле с количеством скачиваний. Поскольку оно всегда начинается с 0, то и переопределять нет необходимости.

Модель описали, теперь надо её зарегистрировать. Это можно сделать двумя способами:
1. В конце файла прописать admin.site.register(models.PostFilesModel, PostFilesAdmin). Где первым параметром передаётся модель из файла models.py, а вторым написанный выше класс для этой модели.
2. С помощью декоратора @admin.register(models.PostFilesModel). В параметр которого передаём необходимую модель.
Субъективно, мне больше нравится второй вариант.
Код:

from django.contrib import admin

from . import models


@admin.register(models.PostFilesModel)
class PostFilesAdmin(admin.ModelAdmin):
    list_display = ('title', 'download_count')
    search_fields = ['title', ]
    exclude = ['download_count', ]

Модель зарегистрирована, давайте проверим её работу.
Запустим Django командой python manage.py runserver и перейдём в панель администратора.

В списке должен появиться блок BLOG с единственным пунктом Файлы постов.
Нажмём на Файлы постов и попадём на страницу со списком записей. Пока что тут пусто.
Нажмём "Добавить" в меню слева или кнопку "Добавить файл поста" в правой части экрана.

В открывшемся окне будет всего два поля, первое название, а второе файл для загрузки. Попробуйте, что-то написать и прикрепить. После чего нажмите "Сохранить".
После сохранения, нас перебрасывает обратно к списку записей и сверху есть плашка с сообщением "Файл поста "Тестовый файл" был успешно добавлен.".
Вернёмся в IDE и в диспетчере файлов увидим, что в корне проекта появилась папка media, а в ней post_files и отправленный ранее файл.
И если мы в адресной строке прямо пропишем путь к файлу: https://127.0.0.1:8000/media/post_files/ваш_файл_включая_расширение, то файл начнёт скачиваться! А по такому-же пути в адресе https://pressanybutton.ru, но с файлом 68.zip будет архивчик с картинками 😉

Файлы загружаются и отдаются пользователю по пути их расположения.
В следующем посте начнём делать API для передачи данных файлов, а вернее их локального пути для Telegram-бота

Файлы к посту, можно получить в боте по коду: 387443
Пост на сайте.
Поддержать канал.

#django #python #модели #админка #admin

Приветствую.

Каналу уже три недели.
За это время на канал подписалось 78 человек!
Посты выходят или каждый день или несколько в день.

В скором времени будет бот, с файлами к постам.
Будет сделан сайт, где можно будет почитать те же посты, но в более удобном формате и со скриншотами.

В ближайшие две недели, выйдет много постов по Django и Aiogram. Доделаем бота и начнём делать блог на сайте.

Я очень надеюсь, что вам нравится, что я делаю. По этому прошу, рассказать о канале друзьям или людям, кому это тоже может быть интересно.

Ещё, хотелось бы видеть больше обратной связи по материалам.
Достаточно ли понятно написано? Нужно ли делать более длинные? И другие возникающие у вас вопросы.

Спасибо вам, за то, что читаете.

Django 10. Пишем API - Сериализатор

С места в карьер! Там где все обычно пишут модели, представления и странички для блога, я же предлагаю окунуться сразу в нечто более полезное, а именно решить поставленную задачу.
Суть задачи в следующем: Необходимо, что бы Telegram-бот обращался к Django по определённому адресу, передавая цифровой код, а в ответ получал расположение файла на сервере и собственно отправлял этот файл пользователю. Этим и займёмся в ближайшие несколько постов, а потом уже можно будет отдохнуть за созданием сайта.

Первым делом необходимо установить библиотеку djangorestframework командой pip install djangorestframework и добавить установленную версию в requirements.txt.
После этого, в директории приложения создадим два файла: api.py и serializers.py.
В файле api.py будем писать обработчики запросов, а в файле serializers.py будет происходить сериализация из данных объекта модели в JSON.

Начинать можно как с сериализатора, так и с обработчика. Но я всё таки рекомендую начинать с сериализатора, так можно сразу определиться с тем, какие данные нам нужно возвращать.

Перейдём в файл serializers.py и создадим класс FileModelSerializer унаследованный от Django REST ModelSerializer.
В нашей модели нет поля path, хранящего путь на сервере до файла, но есть метод для получения такого пути. Но так как сериализатор работает именно с полями модели, а не их методами, создадим новое поле для сериализатора file_path и сделаем его экземпляром класса SerializerMethodField.

Затем создадим класс Meta, на подобии того, что мы делали в модели. Определим в нём поле model и fields. В поле model передадим нашу модель файла, а в поле fields, укажем те поля модели, которые хотим получить, присвоив ему список нужных полей. Нам достаточно поля title и ранее созданного поля file_path.

Поскольку поле file_path у нас создано только для сериализатора, необходимо его заполнить данными. Создадим статический метод get_file_path передавая в атрибуты obj, то есть наш объект модели. В этом методе сделаем возврат пути к файлу или None, если пути нет.
Код:

from rest_framework import serializers

from . import models


class FileModelSerializer(serializers.ModelSerializer):
    file_path = serializers.SerializerMethodField()

    class Meta:
        model = models.PostFilesModel
        fields = ['title', 'file_path']

    @staticmethod
    def get_file_path(obj):
        return obj.file.path if obj.file else None

Таким образом, обратившись к сериализатору FileModelSerializer, и передав в него объект модели PostFilesModel, мы получим данные из двух полей "Название" и "Путь к файлу". А если мы применим к классу метод .data, то в ответ нам вернётся JSON объект.

В следующем посте напишем обработчик GET запроса для нашего API.

Файлы к посту, можно получить в боте по коду: 462013
Пост на сайте.
Поддержать канал.

#django #python #api #serializer #сериализатор #модель