Aplikacja internetowa

Aplikacja internetowa to określenie programów, które pracują w architekturze klient‑serwerklient‑serwerklient‑serwer.

Po stronie serwera umieszcza się m.in. obsługę operacji wykonywanych na bazie danych czy operacji obliczeniowych, czyli całego kodu aplikacji, który nie jest bezpośrednio dostępny dla użytkownika. Ta część to back‑endback‑endback‑end.

Natomiast po stronie klienta znajduje się front‑endfront‑endfront‑end, tj. końcowy efekt działania aplikacji w postaci strony WWW, która jest wyświetlana w przeglądarce. Strony tworzą graficzny interfejs końcowego użytkownika.

Schemat działania aplikacji internetowej polega na tym, że użytkownik z użyciem przeglądarki i protokołu HTTP(S) wysyła żądania do serwera, np. wpisuje adres URL w przeglądarce, aby otrzymać listę dań lub klientów. Oprogramowanie po stronie serwera odbiera i przetwarza żądanie, w tym:

• na podstawie adresu URL rozpoznaje, czy żądanie może być obsłużone,

• jeżeli potrzeba, dokonuje uwierzytelnienia i autoryzacji użytkownika,

• wywołuje funkcje przetwarzające żądanie,

• wykonuje wymagane operacje na bazie, np. odczytuje dane z tabel,

• zwraca odpowiedź do klienta, np. wysyła kod strony WWW zawierającej dane z bazy.

Przygotowywanie tego typu aplikacji jest czynnością złożoną i realizowaną zazwyczaj przez zespół wyspecjalizowanych programistów. My zaś skupimy się na back-endzie, tj. wykonywaniu wybranych operacji na przygotowanej bazie SQLite z wykorzystaniem frameworku języka Python o nazwie Flask oraz języka SQL.

W przypadku front‑endu ograniczymy się do formularzy HTML i minimalnej ilości kodu CSS, aby przygotować strony, które pozwolą wykonywać cztery podstawowe operacje na bazie danych opisywane skrótem CRUD (ang. create, read, update, delete), tj. tworzenie, odczytywanie, modyfikowanie i usuwanie danych.

Katalog aplikacji

Poniżej znajdziesz archiwum zawierające katalog aplikacji.

Pobieramy załączone archiwum restauracja.zip. W systemie Linux archiwum rozpakowujemy w katalogu domowym użytkownika, a w systemie Windows najlepiej w katalogu głównym wybranej partycji, np. oznaczonej literą D:.

Archiwum zawiera katalog o przykładowej nazwie restauracja – od tej pory będziemy nazywali go katalogiem aplikacji. Katalog zawiera plik restauracja.sql, w którym umieściliśmy instrukcje tworzące tabele omówione w poprzednim materiale z serii. Poza tym w katalogu znajdziemy podkatalogi static i templates zawierające pliki potrzebne do budowania stron WWW oraz gotowy kod bazy danych.

W katalogu aplikacji uruchamiamy systemowy wiersz poleceń. W systemach Linux może to być terminal z domyślną powłoką systemową bash. Wpisujemy i wykonujemy kolejno podane niżej komendy:

~/restauracja$ python3 -m venv venv
~/restauracja$ source venv/bin/activate
(venv) ~/restauracja$ pip install flask==2.3.2

W systemie MS Windows uruchamiamy interpreter poleceń PowerShell, wpisujemy i wykonujemy kolejno polecenia:

D:\restauracja> python -m venv venv
D:\restauracja> venv\Scripts\Activate.ps1
(venv) D:\restauracja> pip install flask==2.3.2

Pierwsze polecenie python3 -m venv venv w podkatalogu o nazwie venv tworzy wirtualne środowisko zawierające minimalny zestaw bibliotek języka Python. Polecenie wydajemy raz na początku pracy z aplikacją lub w przypadku usunięcia poprzedniego środowiska.

By móc instalować dowolne biblioteki, a także rozwijać i uruchamiać aplikację niezależnie od systemowej instalacji języka Python, utworzone środowisko trzeba aktywować, wydając drugie polecenie, np. source venv/bin/activate.

Ostatnie polecenie pip install flask==2.3.2 umożliwia zainstalowanie podanej biblioteki, tzn. frameworku Flask w wersji 2.3.2, z której korzystamy w e‑materiałach. Wydajemy je raz po utworzeniu środowiska.

Aplikacja Restauracja

W pliku o nazwie app.py umieszczamy minimum kodu potrzebnego do uruchomienia aplikacji:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Strona główna'

with app.app_context():
    if __name__ == "__main__":
        app.run(debug=True)

Aplikację uruchamiamy w wierszu poleceń otwartym w katalogu aplikacji z aktywnym środowiskiem wirtualnym za pomocą polecenia flask run --debug.

Inna możliwość to wydanie polecenia python3 app.py (Linux) lub python app.py (MS Windows).

RLGson9kPTN5E

Przykład uruchomienia aplikacji w systemie Linux.

Jak widać na zrzucie ekranu, w trybie deweloperskim aplikacja uruchamia serwer WWW, który używa protokołu http i nasłuchuje żądań na adresie pętli zwrotnej i porcie 127.0.0.1:5000. Kiedy w przeglądarce internetowej wpiszemy podany adres i zatwierdzimy klawiszem ENTER lub klikniemy adres w terminalu z wciśniętym klawiszem CTRL (to powinno spowodować otwarcie przeglądarki), przeglądarka wyśle do serwera żądanie typu GET o zwrócenie zasobu domyślnego z głównego katalogu serwera. Zasób ten dostępny jest pod adresem URL http://127.0.0.1:5000/ – znak prawego ukośnika (ang. slash) na końcu oznacza główny katalog serwera.

Po otrzymaniu żądania aplikacja działająca po stronie serwera sprawdzi wszystkie adresy URL zdefiniowane w dekoratorachdekoratordekoratorach route() i jeżeli znajdzie dopasowanie, wywoła funkcję, która ma adres obsłużyć. W pliku app.py dodaliśmy adres URL „/”, który ma zostać obsłużony przez funkcję index().

@app.route('/')
def index():
    return 'Strona główna'

Adres URL, który podajemy w dekoratorze route(), pozbawiony jest protokołu i adresu serwera (nazwy hosta). Funkcja języka Python, która znajduje się poniżej, nazywana jest widokiemwidokwidokiem (ang. view) i powinna zwracać jakąś wartość. W najprostszym przypadku jest to ciąg znaków, który zostanie odesłany jako odpowiedź do przeglądarki: return 'Strona główna'.

Wynikiem wszystkich opisanych operacji będzie wyświetlenie w przeglądarce tekstu Strona główna.

REVPCOxH7WRSo

Widoczna jest strona główna i adres.

Połączenia z bazą danych

W kolejnym kroku przygotujemy moduł, w którym znajdą się funkcje obsługujące połączenie z bazą danych. W katalogu aplikacji tworzymy nowy plik o nazwie db.py, w którym umieszczamy następujący kod:

import sqlite3
from flask import g, current_app

def get_db():
    """Funkcja tworzy połączenie z bazą"""
    if 'db' not in g:
        g.db = sqlite3.connect(
            current_app.config['DATABASE'],
            detect_types = sqlite3.PARSE_DECLTYPES
        )
        g.db.row_factory = sqlite3.Row
    return g.db

def close_db(e=None):
    """Funkcja zamyka połączenia z bazą"""
    db = g.pop('db', None)
    if db is not None:
        db.close()

def init_app(app):
    """Funkcja rejestruje funkcję close_db() w aplikacji"""
    app.teardown_appcontext(close_db)

def init_db():
    """Funkcja tworzy bazę i tabele"""
    db = get_db()
    with current_app.open_resource('restauracja.sql') as f:
        db.executescript(f.read().decode('utf8'))

Zadaniem funkcji get_db() jest nawiązanie połączenia z bazą i udostępnienie obiektu pozwalającego na wykonywanie na niej operacji w kontekście aplikacji. Do metody connect() z modułu sqlite3 przekazujemy nazwę pliku bazy danych zapisaną w słowniku current_app.config['DATABASE'] oraz argument detect_types = sqlite3.PARSE_DECLTYPES. Flaga PARSE_DECLTYPES oznacza, że baza będzie używała odpowiednich funkcji konwertujących typy danych języka Python na typy danych przechowywane w bazie. Ustawienie row_factory = sqlite3.Row spowoduje, że wyniki zapytań (rekordy) będą zwracane w postaci słowników, w których kluczami będą nagłówki pól.

Zadaniem funkcji db_close() jest zamykanie połączenia z bazą. Funkcja powinna być wywoływana po zakończeniu obsługi każdego żądania, dlatego kolejna funkcja init_app() rejestruje funkcję close_db() za pomocą metody teardown_appcontext() w aplikacji.

Funkcję db_int() wykorzystamy do utworzenia tabel zdefiniowanych w pliku restauracja.sql w pustej bazie danych.

W kolejnym kroku modyfikujemy plik app.py:

import os
from flask import Flask, current_app, render_template
from db import init_app, init_db

app = Flask(__name__)

app.config.from_mapping(
    SECRET_KEY='restauracja_dev',
    DATABASE=os.path.join(app.root_path, 'restauracja.db'),
    SITE_NAME='Restauracja'
)

init_app(app)

@app.route('/')
def index():
    return 'Strona główna'

with app.app_context():
    if not os.path.exists(current_app.config['DATABASE']):
        init_db()
    if __name__ == "__main__":
        app.run(debug=True)

Przede wszystkim uzupełniamy importy, a następnie dodajemy słownik konfiguracyjny config. Klucz SECRET_KEY zawiera ciąg znaków wykorzystywany do zarządzania sesjami – tym zagadnieniem zajmiemy w kolejnym e‑materiale. Klucz DATABASE wskazuje plik bazy danych restauracja.db, który zostanie utworzony w głównym katalogu aplikacji – nie jest to rozwiązanie zalecane ze względów bezpieczeństwa, ale przyjmujemy je dla uproszczenia. Klucz SITE_NAME to po prostu nazwa aplikacji.

Pozostaje nam ponowne uruchomienie aplikacji. W katalogu aplikacji powinien zostać utworzony plik bazy restauracja.db.

Dania w restauracji

Nasza baza danych składa się z tabel, które możemy traktować jako obiekty. Obsługę poszczególnych obiektów umieścimy w osobnych modułach, określanych we Flasku słowem blueprint. W tym kontekście możemy je rozumieć jako projekt. Zaletą korzystania z projektów jest łatwiejsze utrzymanie porządku i przejrzystości w kodzie oraz możliwość wykorzystania ich w wielu aplikacjach.

W katalogu aplikacji dodajemy plik o nazwie dania.py i umieszczamy w nim następujący kod:

from flask import (
    Blueprint, flash, render_template, request, redirect, url_for
)
from werkzeug.exceptions import abort
from db import get_db

bp = Blueprint('dania', __name__, url_prefix='/dania')

Projekt jest instancją klasy Blueprint(), której konstruktor otrzymuje nazwę projektu 'dania' oraz nazwę modułu zawierającego projekt – w tym przypadku jest to nazwa dania.py zwracana przez zmienną name. Trzecim opcjonalnym parametrem jest prefix, którym będą poprzedzane zdefiniowane w projekcie adresy URL.

Widoki

Obsługa każdej operacji wykonywanej na obiektach (tabelach) bazy danych realizowana jest z wykorzystaniem funkcji zwanych widokamiwidokwidokami.

Do pliku dania.py dodajemy kod widoku wyświetlającego listę dań oraz nagłówki widoków, które będą obsługiwały pozostałe operacje:

@bp.route('/lista')
def lista():
    db = get_db()
    dane = db.execute('SELECT * FROM dania').fetchall()
    if not dane:
        flash('Brak dań!')
    return render_template('dania_lista.html', dane=dane)

@bp.route('/dodaj', methods=['GET', 'POST'])
def dodaj(d_id):
    pass

def get_danie(d_id):
    pass

@bp.route('/<int:d_id>/edytuj', methods=['GET', 'POST'])
def edytuj(d_id):
    pass

@bp.route('/<int:d_id>/usun', methods=['GET', 'POST'])
def usun(d_id):
    pass

Na początku za pomocą dekoratora route() definiujemy adres URL, dla którego chcemy obsłużyć żądanie, np.: @bp.route('/lista'). Argument '/lista' oznacza adres: http(s)://nazwa_serwera/dania/lista.

Domyślnie obsługiwane są żądania typu GET, czyli pobranie zasobu wskazanego przez URL. Jeżeli chcemy obsłużyć żądanie typu POST, czyli przyjęcie danych przesłanych od klienta do serwera, umieszczamy obydwa typy żądań w argumencie methods: methods=['GET', 'POST'].

Adresy URL mogą zawierać zmienne, np. /<int:d_id>/edytuj, /<int:d_id>/usun. Zmienne te (typu całkowitego) wykorzystamy do przekazania widokom identyfikatorów dań, które będziemy chcieli modyfikować lub usunąć. Przykładowy adres URL, który będzie pozwalał na modyfikację dania, może wyglądać np. tak: /dania/1/edytuj.

Przeanalizujmy działanie widoku lista().

Po utworzeniu obiektu reprezentującego połączenie z bazą za pomocą metody execute() wykonujemy zapytanie SQL, które wybiera wszystkie rekordy z tabeli dania. Metoda fetchall() zwraca wszystkie pobrane rekordy w postaci listy. Zwrócone rekordy możemy traktować jak słowniki, np.:

[{'id': 1, 'nazwa': 'zupa ogórkowa', 'cena': 17.5, 'menu': 1},
 {'id': 2, 'nazwa': 'zupa pomidorowa', 'cena': 18, 'menu': 1},
 {'id': 3, 'nazwa': 'barszcz czerwony', 'cena': 14, 'menu': 1}]

Funkcja render_template() wywołuje podany jako pierwszy argument szablon HTML i przekazuje do niego dodatkowe dane, w tym przypadku listę rekordów, która w szablonie będzie dostępna pod nazwą dane. Po przetworzeniu szablonu, co bywa nazywane renderowaniemrenderowanierenderowaniem, przygotowany kod HTML zostanie zwrócony jako odpowiedź na żądanie.

Szablony

W przyjętej przez nas konfiguracji szablony umieszczamy w podkatalogu templates katalogu aplikacji. Ponieważ w obrębie jednego serwisu wiele elementów na stronach WWW powtarza się, korzystamy z szablonu bazowego zapisanego w pliku base.html, którego zawartość jest następująca:

<!DOCTYPE html>
<html lang="pl">
<head>
  <meta charset="utf-8">
  <title>{% block title %}Restauracja{% endblock %}</title>
  <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='style.css') }}">
</head>
<body>
    <header class="center-txt">
      <h1>Restauracja</h1>
      <h2>{% block podtytul %}{% endblock %}</h2>
    </header>

  <nav class="center menu">
    <p>
      <a href="{{ url_for('index') }}">Restauracja</a>
      – <a href="{{ url_for('dania.lista') }}">Dania</a>
    </p>
  </nav>

{% with komunikaty = get_flashed_messages() %}
{% if komunikaty %}
  <section class="center info">
      <p>
        {% for komunikat in komunikaty %}
        <span class="{{ kategoria }}">{{ komunikat }}</span><br>
        {% endfor %}
      </p>
  </section>
{% endif %}
{% endwith %}

  <section class="center tresc">
    {% block tresc %}{% endblock %}
  </section>

 <footer>Wykonano w aplikacji <a href="https://flask.palletsprojects.com/en/2.3.x/">Flask v. 2.3.2</a>.</footer>

</body>
</html>

Szablon jest zwykłym plikiem tekstowym, który poza kodem HTML zawiera tagi oznaczane ogranicznikami:

• {{ zmienna lub wyrażenie }} – tagi zawierające zmienne lub wyrażenia pozwalają umieszczać na stronie wartości zmiennych lub wyrażeń,

• {% instrukcja %} – tagi sterujące pozwalają korzystać z instrukcji takich jak if, for czy with oraz definiować bloki (block), których treść może być nadpisywana lub uzupełniana w szablonach dziedziczących. Tagi te mają otwarcie i zamknięcie, np.: {% if komunikaty %} ... {% endif %} lub {% block tresc %} ... {% endblock %}.

Do generowania adresów URL w szablonie używamy funkcji url_for(). W najprostszej postaci argumentem funkcji jest nazwa widoku (tj. funkcji skojarzonej z adresem URL) z ewentualnym prefiksem, tj. nazwą blueprinta, np.: {{ url_for('dania.lista') }}.

Funkcja get_flashed_messages() zwraca listę komunikatów przygotowywanych w widokach za pomocą funkcji flash(), np. flash('Brak dań!').

Strona główna

W katalogu templates znajdziemy również plik index.html o następującej zawartości:

{% extends 'base.html' %}
{% block podtytul %}Strona główna{% endblock %}
{% block tresc %}Witamy!{% endblock %}

Pierwsza linia oznacza, że zawartość dziedziczona jest z szablonu base.html. Druga i trzecia linia pokazują, w jaki sposób wstawiamy treść do zdefiniowanych w szablonie bazowym bloków.

Szablon listy dań

Teraz dodamy szablon, który pozwoli pokazać listę dań. Do katalogu templates dodajemy nowy plik o nazwie dania_lista.html z następującą zawartością:

{% extends "base.html" %}
{% block podtytul %}Dania – lista{% endblock %}

{% block tresc %}
  <ol>
    {% for rekord in dane %}
      <li>{{ rekord.nazwa }}, {{ rekord.cena }}, {% if rekord.menu %} dostępne {% else %} niedostępne {% endif %} –
        <a href="{{ url_for('dania.edytuj', d_id=rekord.id) }}">Edytuj</a>,
        <a href="{{ url_for('dania.usun', d_id=rekord.id) }}">Usuń</a>
      </li>
    {% endfor %}
  </ol>
  <p><a href="{{ url_for('dania.dodaj') }}">Dodaj danie</a></p>
{% endblock %}

Najważniejszym fragmentem jest pętla for, która odczytuje kolejne rekordy z listy dane. Dostęp do pól rekordu uzyskujemy dzięki notacji z kropką, np.: rekord.nazwa. Kolejne wywołania funkcji url_for() generują adresy URL pozwalające na modyfikowanie, usuwanie i dodawanie dań.

Rejestracja projektu

Projekt obsługujący dania musimy zarejestrować w aplikacji. Modyfikujemy fragment pliku app.py:

import os
from flask import Flask, current_app, render_template
from db import init_app, init_db
import dania

app = Flask(__name__)

app.config.from_mapping(
    SECRET_KEY='restauracja_dev',
    DATABASE=os.path.join(app.root_path, 'restauracja.db'),
    SITE_NAME='Restauracja'
)

init_app(app)
# rejestracja projektów
app.register_blueprint(dania.bp)


@app.route('/')
def index():
    # return 'Strona główna'
    return render_template('index.html')

with app.app_context():
    if not os.path.exists(current_app.config['DATABASE']):
        init_db()
    if __name__ == "__main__":
        app.run(debug=True)

Przede wszystkim dodajemy import modułu dania. Następnie rejestrujemy blueprint dania w aplikacji: app.register_blueprint(dania.bp) – od tej pory obsługiwane będą zdefiniowane w nim adresy URL.

Dodatkowo w widoku index() umieszczamy wywołanie funkcji renderującej szablon strony głównej return render_template('index.html').

Uruchamiamy aplikację, otwieramy stronę główną, a następnie klikamy w link Dania. Powinniśmy zobaczyć pokazane na zrzutach strony.

Rf0zLP9MzhxX4

Widoczna jest Strona główna serwisu z zaznaczonym adresem.

R1CWaUsWABZuj

Widoczna jest Strona z listą dań z zaznaczonym adresem.

Dodawanie dań

Uzupełniamy widok dodaj():

@bp.route('/dodaj', methods=['GET', 'POST'])
def dodaj():
    if request.method == 'POST':
        nazwa = request.form['nazwa'].strip()
        cena = request.form['cena'].strip()
        menu = 0
        if 'menu' in request.form:
            menu = 1
        db = get_db()
        db.execute('INSERT INTO dania VALUES (?, ?, ?, ?)', [None, nazwa, cena, menu])
        db.commit()
        flash(f'Dodano danie: {nazwa}')
        return redirect(url_for('dania.lista'))

    return render_template('danie_dodaj.html')

Obiekt request zawiera wszystkie informacje przesłane w żądaniu, m.in. typ. Jeżeli otrzymamy żądanie typu GET, zwracamy szablon danie_dodaj.html, który zawiera formularz HTML pozwalający przesłać informacje o daniu.

Po wysłaniu formularza otrzymamy żądanie typu POST. Wtedy ze słownika form odczytujemy wartości kolejnych pól formularza. Nawiązujemy połączenie z bazą i wykonujemy zapytanie INSERT INTO dania VALUES (?, ?, ?, ?). Znaki zapytania, zostaną zastąpione kolejnymi podanymi w liście lub tupli, wartościami: [None, nazwa, cena, menu].

Po zatwierdzeniu zapytania przygotowujemy komunikat dla użytkownika za pomocą funkcji flash(), a następnie przekierowujemy obsługę żądania do widoku lista() za pomocą instrukcji return redirect(). Argumentem funkcji redirect() jest adres URL zwrócony przez omawianą już funkcję url_for().

Do katalogu templates dodajemy szablon danie_dodaj.html:

{% extends "base.html" %}
{% block podtytul %}Danie – dodawanie{% endblock %}

{% block tresc %}
  <form method="POST" action="{{ url_for('dania.dodaj') }}">
    <label for="nazwa">Nazwa:</label>
    <input type="text" id="nazwa" name="nazwa" value="" required>
    <br>
    <label for="cena">Cena:</label>
    <input type="number" id="cena" name="cena" min=".01" value="0.01" step=".01" required>
    <br>
    <label for="menu">Czy w menu:</label>
    <input type="checkbox" id="menu" name="menu" checked="checked">
    <br>
    <button type="submit">Dodaj</button>
  </form>
{% endblock %}

Po uruchomieniu aplikacji będziemy mogli dodawać dania.

R1Whq4BWLJ3tD

Widoczny jest Formularz dodawania dań z zaznaczonym adresem.

R9l9umZPiRUSf

Widoczne jest Potwierdzenie dodania dania z zaznaczoną informacją dodano danie żurek biały.

Edycja dań

W pliku danie.py uzupełniamy kod funkcji pomocniczej get_danie() oraz widok edytuj():

def get_danie(d_id):
    db = get_db()
    danie = db.execute('SELECT * FROM dania WHERE id = ?', [d_id]).fetchone()
    if danie is None:
        abort(404, f"Danie o id {id} nie istnieje.")
    return danie


@bp.route('/

Adres URL edycji dania zawiera jego identyfikator, który zostaje przekazany jako argument d_id do widoku. Na początku korzystamy z funkcji get_danie(), aby odczytać odpowiedni rekord z bazy. Jeżeli dania o podanym identyfikatorze w bazie nie ma, do klienta zostanie zwrócona strona z kodem błędu 404 i odpowiednim komunikatem.

R1aQn4tn1SKt6

Widoczna jest strona z kodem błędu 404 i komunikatem danie o id 10 nie istnieje. Zaznaczony jest adres strony.

Jeżeli funkcja get_danie() zwróci informacje o daniu, w przypadku żądania typu GET zwracamy szablon danie_edytuj.html, który zawiera taki sam formularz, jak podczas dodawania dania, z tym że jego pola uzupełniamy informacjami o daniu przekazanymi w zmiennej rekord.

R16eT4876Y9oM

Widoczna jest Edycja dania. żurek biały, cena 16,99, pole czy w menu jest zaznaczone.

Po otrzymaniu żądania typu POST i danych z formularza wykonujemy te same operacje jak podczas tworzenia dania, tj. ustalamy wartości poszczególnych pól. Następnie wykonujemy zapytanie 'UPDATE dania SET nazwa = ?, cena = ?, menu = ? WHERE id = ?', i przekazujemy wartości pól w odpowiedniej kolejności w liście: [nazwa, cena, menu, d_id].

Na koniec zatwierdzamy zmiany w bazie, przygotowujemy komunikat i za pomocą przekierowania zwracamy listę dań.

RLfYgdviR3Hyj

Widoczne Potwierdzenie zaktualizowania dania id 4 żurek biały.

Zanim sprawdzimy działanie edycji, szablon danie_edytuj.html umieszczamy w katalogu templates:

{% extends "base.html" %}
{% block podtytul %}Danie – edycja{% endblock %}

{% block tresc %}
  <form method="POST" action="{{ url_for('dania.edytuj', d_id=rekord.id) }}">
    <label for="nazwa">Nazwa:</label>
    <input type="text" id="nazwa" name="nazwa" value="{{ rekord.nazwa }}" required>
    <br>
    <label for="cena">Cena:</label>
    <input type="number" id="cena" name="cena" min=".01" value="{{ rekord.cena }}" step=".01" required>
    <br>
    <label for="menu">Czy w menu:</label>
    <input type="checkbox" id="menu" name="menu" {% if rekord.menu %} checked="checked" {% endif %}>
    <br>
    <button type="submit">Zapisz</button>
  </form>
{% endblock %}

Usuwanie dań

Uzupełniamy kod widoku usun() w pliku dania.py:

@bp.route('/<int:d_id>/usun', methods=['GET', 'POST'])
def usun(d_id):
    rekord = get_danie(d_id)
    if request.method == 'POST':
        db = get_db()
        db.execute('DELETE FROM dania WHERE id = ?', [d_id])
        db.commit()
        flash(f'Usunięto danie id {d_id} {rekord["nazwa"]}')
        return redirect(url_for('dania.lista'))
    return render_template("danie_usun.html", rekord=rekord)

Dodajemy szablon danie_usun.html:

{% extends "base.html" %}
{% block podtytul %}Danie – usuwanie{% endblock %}

{% block tresc %}
  <form method="POST" action="{{ url_for('dania.usun', d_id=rekord.id) }}">
    <p>Czy na pewno usunąć danie:</p>
    <p>{{ rekord.nazwa }}, {{ rekord.cena }}, {% if rekord.czy_w_menu %} dostępne {% else %} niedostępne {% endif %}</p>
    <br>
    <button type="submit">Usuń</button>
  </form>
{% endblock %}

Jeżeli otrzymamy adres URL np. w postaci /dania/1/usun, wówczas podobnie jak w przypadku edycji próbujemy odczytać odpowiedni rekord z bazy, aby sprawdzić, czy danie o podanym identyfikatorze (d_id) istnieje. Jeśli tak, wyświetlamy prosty formularz (odpowiedź na żądanie typu GET) umożliwiający użytkownikowi potwierdzenie usunięcia danych. Jeżeli użytkownik naciśnie przycisk Usuń (żądanie typu POST), wykonujemy zapytanie DELETE FROM dania WHERE id = ?, w którym znak zapytania zastąpiony zostanie identyfikatorem dania: [d_id]. Po zatwierdzeniu zmian przygotowujemy komunikat (flash()) i wyświetlamy listę dań (return redirect()).

R1XE14QouBmTB

Widoczny jest Formularz usuwania dania żurek biały. Zaznaczony jest adres strony.

RILuffJk1pEQP

Widoczne jest Potwierdzenie usunięcia dania żurek biały.

Słownik