Průvodce vytvořením aplikace pro zkracování adres URL s Django

autor:
Tweet
Share
Share
Pin

Nejlepší způsob, jak se naučit Django nebo jakoukoli dovednost, je aplikovat znalosti, které máte, vytvářením funkčních projektů.

Django je nejpoužívanější framework pro vývoj webových aplikací Python. Jeho vestavěné funkce a rozsáhlé množství balíčků třetích stran z něj udělaly jeden z nejoblíbenějších webových rámců na celém světě.

Je rychlý, spolehlivý a má mnoho vestavěných funkcí. Například systém ověřování děr, který vám umožní soustředit se na hlavní funkce vaší aplikace. Můžete také nainstalovat externí balíčky pro provádění ještě složitějších úkolů, jako je Django-allauth, který vám umožňuje registrovat uživatele pomocí jejich sociálních účtů.

Pojďme si ale prozradit některá fakta. Django je tak obrovský rámec, že ​​je někdy náročné s ním začít.

Takže dnes se chystáte postavit od nuly zcela funkční aplikaci Django.

Na konci tohoto tutoriálu budete:

  • Napsali jste aplikaci pro zkracování adres URL
  • Pochopte vzor Django MVT
  • Naučili jste se pracovní postup vytváření projektu

Předběžné požadavky

Všechny následující požadavky jsou volitelné a pomohou vám dodržet je spolu s výukovým programem. Pokud ale s žádným z nich nemáte zkušenosti, nebojte se. Nejdůležitější krok je první.

  • Základní znalost příkazů UNIX (ls, cd, rm, touch)
  • Základní pochopení tříd a funkcí Pythonu
  • Python nainstalovaný na vašem počítači (možná zřejmé, ale musel jsem ho zahrnout)
  • Bylo by skvělé, kdybyste už něco postavili s Django

Na tomto bude k dispozici veškerý pracovní kód Github repo.

Nyní, když máte křišťálově jasné předchozí pojmy, pojďme k věci.

Prohlášení projektu

V tomto tutoriálu vytvoříte zkracovač URL. Zkracovač URL je v podstatě služba, která vezme dlouhou adresu URL a přemění ji na kompaktní.

Pokud například chcete sdílet tweet a chcete zahrnout odkaz na svůj web, ale čelíte omezení počtu znaků, můžete použít zkracovač adres URL.

Podívejme se na to s grafikou.

Jak vidíte, zkracovač URL získá dlouhou adresu URL a vrátí krátkou adresu. To je přesně to, co se dnes chystáte postavit.

S tímto projektem si procvičíte používání vzoru MVT, naučíte se základy návrhu databáze s modely Django a naučíte se, jak zobrazovat informace uživateli prostřednictvím pohledů, adres URL a šablon.

Struktura projektu Django

Web Django je v zásadě postaven na jediném projektu a několika samostatných aplikacích. Každá z těchto aplikací má specifické funkce a je schopna fungovat sama o sobě.

Představme si komplexní webovou aplikaci jako Přetečení zásobníku. Jeho funkčnost je založena na dvou hlavních aspektech.

  • Správa uživatelů: Přihlášení, Odhlášení, Reputace, Oprávnění
  • Fórum: Otázky, odpovědi, štítky, filtry

Takže podle struktury webu Django by se projekt jmenoval StackOverflow, který má dvě hlavní aplikace. Aplikace uživatelů a aplikace fóra.

Každá z těchto aplikací má samostatné funkce. To znamená, že oba obsahují veškerý kód, který potřebují ke správnému fungování.

To zahrnuje modely (struktura databáze), pohledy (požadavky a odpovědi), specifické vzory adres URL a samozřejmě šablony a statické soubory (obrázky, CSS, JavaScript). To znamená, že jakoukoli aplikaci Django lze znovu použít, protože jsou schopny pracovat samy.

Zkráceně, projekt odkazuje na sadu konfigurací a aplikací, které jsou určeny k vytvoření webové aplikace. Na druhou stranu je aplikace Django součástí projektu, který je samostatný (má vše, co k fungování potřebuje) a jeho účelem je provedení konkrétní operace.

Nastavte projekt Django

V této sekci se chystáte nastavit projekt Django. Za tímto účelem budete používat různé nástroje, jako je virtuální prostředí k uspořádání závislostí Pythonu a nejdůležitější skripty Django. Django-admin a manage.py

Virtuální prostředí

Vždy doporučuji pracovat s virtuální prostředí při vytváření aplikací s Django. Je to nejúčinnější způsob, jak udržovat určitou sadu závislostí. Jeho hlavním účelem je ale izolovat vývojové balíčky od těch globálních.

Pojďme tedy vytvořit virtuální prostředí pomocí pythonu vestavěného příkazu formuláře.

Poznámka: Tato metoda vyžaduje, aby fungovala Python 3.6 nebo novější verze.

python -m venv .venv

Tento příkaz používá příkaz python -m nebo python –mod. V zásadě spouští modul nebo knihovnu jako skript. Podle významu tohoto příkazu je venv knihovna, kterou spouštíme, a .venv odkazuje na název virtuálního prostředí, které chceme vytvořit.

Takže v jednoduchém jazyce tento příkaz znamená.

Ahoj Pythone, spusťte jako skript vestavěnou knihovnu venv a vytvořte název virtualenv .venv

Nyní je čas aktivovat virtuální prostředí, které jsme právě vytvořili, pomocí následujícího příkazu.

source .venv/bin/activate

Chcete-li potvrdit, že v novém venv nemáte nainstalované žádné balíčky, spusťte.

pip freeze

Pokud jste správně aktivovali virtuální prostředí, nezískáte žádný výstup. To proto, že jsme ještě nic neinstalovali.

Pojďme do Djanga

Abychom vytvořili naši aplikaci pro zkracování adres URL, začneme instalací balíčku Django. Django je balíček třetí strany, proto jej musíme nainstalovat pomocí Pip (Pip Installs Packages).

$ pip install django
Collecting django
  Downloading Django-3.2.1-py3-none-any.whl (7.9 MB)
     |████████████████████████████████| 7.9 MB 344 kB/s 
Collecting asgiref<4,>=3.3.2
  Using cached asgiref-3.3.4-py3-none-any.whl (22 kB)
Collecting sqlparse>=0.2.2
  Using cached sqlparse-0.4.1-py3-none-any.whl (42 kB)
Collecting pytz
  Using cached pytz-2021.1-py2.py3-none-any.whl (510 kB)
Installing collected packages: asgiref, sqlparse, pytz, django
Successfully installed asgiref-3.3.4 django-3.2.1 pytz-2021.1 sqlparse-0.4.1

Poznámka: Pamatujte, že $ není nic jiného než váš symbol shellu.

Abychom zkontrolovali, zda instalace proběhla správně, znovu zkontrolujeme nainstalované balíčky našeho venv.

$ pip freeze
asgiref==3.3.4
Django==3.2.1
pytz==2021.1
sqlparse==0.4.1

Nedělejte si starosti, pokud se verze, které získáte, liší od mých. Pokud Django zůstává na verzi 3.x, můžete bez problémů pokračovat.

Zahájení projektu Django

Jakmile nainstalujete Django, je čas vytvořit strukturu webu zkracovače URL. Pamatujete si, co je projekt Django? Vytvoříme jej spuštěním následujícího příkazu.

django-admin startproject config

Vše o tomto příkazu vysvětluje, django-admin je nástroj příkazového řádku, který provádí všechny potřebné úkoly k vytvoření projektu Django. Část „startproject“ je příkaz spuštěný nástrojem Django-admin a config je název projektu, který se chystáme vytvořit.

Je důležité zdůraznit, že config může mít libovolný název. Důvod, proč používám config jako název tohoto projektu, je jen z pohodlí. Je příjemné přepínat mezi projekty a mít stále stejnou konvenci pojmenování. Nebojte se tedy používat jiné názvy projektů, kdykoli budete chtít.

Jak si můžete všimnout, nyní máte složku config/ a uvnitř je mnoho souborů. Později uvidíme souborovou strukturu projektu. Nyní vstoupíme do adresáře projektu a spustíme lokální server.

cd config/

Nejdůležitější soubor, který budete používat, je skript manage.py. Má stejnou funkcionalitu jako django-admin, ale hlavní výhodou jeho použití je, že vám umožňuje spravovat nastavení při spuštění projektu.

Nyní se podívejme, zda vše funguje správně.

python manage.py runserver

Vytvoření aplikace pro zkracování adres URL

Je čas vytvořit hlavní aplikaci projektu. K provedení tohoto úkolu použijete soubor manage.py.

python manage.py startapp urlshortener

Tím se vytvoří aplikace Django s názvem urlshortener. Pokud spustíte strom příkaz, dostanete něco takového.

.
├── config
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
└── urlshortener
    ├── admin.py
    ├── apps.py
    ├── __init__.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── tests.py
    └── views.py

Pojďme si ujasnit různé soubory vytvořené do této chvíle. „config“ je název našeho projektu a jmenuje se tak jen kvůli konvenci. Uvnitř config získáte settings.py, je to soubor, kde nastavíte všechna nastavení vašeho projektu. urls.py je celková konfigurace URL v projektu. Definuje cesty URL všech aplikací v rámci projektu.

Se soubory asgi.py a wsgi.py si příliš nedělejte starosti. Jedná se o soubory, které umožňují konfigurovat aplikaci v nasazení.

Správa.py je skript pythonu, který vám umožňuje spouštět všechny dostupné příkazy Django-admin.

Když se podíváte do urlshortener, což je název aplikace, kterou jste právě vytvořili, můžete si všimnout, že existuje podivná složka s názvem „migrations/“ a některé další soubory, které jsou zásadní pro logiku jakékoli aplikace.

apps.py je místo, kde žije konfigurace aplikace. Obvykle si s tím nelámete hlavu, kromě toho, že děláte dost pokročilé věci.

admin.py je místo, kde registrujete své modely, aby byly viditelné na panelu administrátora Django.

models.py je nejdůležitější. Uvnitř tohoto modulu musíte definovat modely, které (mále řečeno) jsou způsobem ukládání dat. Více o modelech uslyšíte později.

Migrace/ je složka, kde se ukládají migrace Django. Později se na to podíváme do hloubky.

testy.py je soubor, ve kterém jsou uloženy testy. V tomto tutoriálu se nebudeme zabývat testováním.

views.py je soubor, který ukládá zobrazení. V podstatě definuje, jak bude uživatel interagovat se všemi aspekty vaší aplikace.

Instalace aplikace Django

Než budete pokračovat, otevřete soubor settings.py a upravte proměnnou INSTALLED_APPS přidáním aplikace urlshortener.

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # Custom apps
    'urlshortener',
]

Toto je rutinní proces, když vytváříte aplikaci. Takže pokaždé, když to uděláte, nezapomeňte si to nainstalovat do nastavení projektu.

Pochopení vzoru MVT

Vzor Model, Zobrazit, Šablona je vzor návrhu softwaru, který vývojáři Django používají k vytváření webových aplikací.

Je založen na 3 hlavních konceptech. Model (data), View (Interakce uživatele s daty), Template (Jak uživatelé vidí data).

Modely jsou třídy Pythonu, které definují všechna pole a chování dat, která jste ochotni uložit. Normálně každý model odkazuje na jedinečnou tabulku v databázi

Pohledy ve svém nejjednodušším vyjádření jsou callables, které přijímají požadavek od uživatele a generují odpověď. Mezi tímto procesem se nachází obchodní logika. Vím, že „obchodní logika“ je docela obskurní pojem, takže mi dovolte vysvětlit, co to přesně je. Obchodní logika je způsob, jakým jsou data vytvářena, ukládána a mazána, to je vše.

A konečně, šablony jsou textové dokumenty (obvykle Html), které se zobrazují uživatelům. Jeho účelem je prezentovat data co nejčistěji. Django obsahuje mini-jazyk tzv Jazyk šablon Django (DTL) což vám umožní začlenit část výkonu pythonu do textových dokumentů.

Vytvořte model zkracovače

Jakmile budete mít rychlý přehled o vzoru MVT, pojďme se pustit do vytváření zkracovače URL Django od začátku.

Nejprve si nadefinujme model zkracovače uvnitř souboru models.py.

'''
Url shortener model
'''

from django.db import models

# Create your models here.

class Shortener(models.Model):
    '''
    Creates a short url based on the long one
    
    created -> Hour and date a shortener was created 
    
    times_followed -> Times the shortened link has been followed

    long_url -> The original link

    short_url ->  shortened link https://domain/(short_url)
    ''' 
    created = models.DateTimeField(auto_now_add=True)

    times_followed = models.PositiveIntegerField(default=0)    

    long_url = models.URLField()

    short_url = models.CharField(max_length=15, unique=True, blank=True)

    class Meta:

        ordering = ["-created"]


    def __str__(self):

        return f'{self.long_url} to {self.short_url}'

Vím. Je to docela velká třída se spoustou divných věcí, ale nezoufejte. Půjdu krok za krokem ke každé důležité věci.

Vysvětlení modelu

Nejprve importujeme modul modely. Tento modul obsahuje všechny funkce, které potřebujeme k vytvoření modelu Django.

Když se podíváme na model „Shortener“, první věc, kterou je třeba poznamenat, je, že rozšiřuje modely. Model. Ve skutečnosti každý model v jakékoli aplikaci Django musí být podtřídou třídy modely.Model třída.

Poté definujeme všechna pole, která bude mít model v databázi. Pole „vytvořeno“ je datum a čas vytvoření zkráceného odkazu, proto k vytvoření tohoto druhu funkce používáme DateTimeField. Použijeme argument auto_now_add=True, protože chceme, aby se pole změnilo pouze při vytvoření instance.

Druhé pole times_followed odkazuje na časy použití zkrácené adresy URL. Je to PositiveIntegerField a zadáváme výchozí hodnotu nula. To znamená, že pokaždé, když instance vytvoří pole times_followed, Django toto pole vyplní 0.

Na druhou stranu long_url odkazuje na adresu URL, kterou uživatel zadá. Jedná se o URLField, protože chceme, aby uživatel zadával pouze znaky ve tvaru: http://yoursite.com.

Poslední pole je short_url a obsahuje zajímavé detaily. Uvádíme, že může mít pouze 15 znaků, musí být unikátní, což znamená, že se v tomto poli nemohou opakovat prvky. Nakonec uvádíme, že může být ponecháno prázdné, což znamená, že při práci s formuláři uživatelé nebudou muset psát svůj vlastní zkrácený kód.

Vnitřní třída Meta nám říká, jak se třída musí chovat, a nastavíme, že řazení (volání Shortener.objects.all()) objektů zkracovače bude rozlišeno podle nejnovějších.

Metoda __str__ říká, jak musí být model vytištěn. Pokud tedy máme objekt s long_url = “https://etechblog.cz.com/” a zkrácenou částí “123456”, a vytiskneme jej.

https://etechblog.cz.com/ to 123456

Nyní je čas vyhledat způsob, jak uložit krátký odkaz náhodným způsobem.

Vytvoření funkce zkracování

Vytvoříme 2 vlastní funkce. První vygeneruje náhodný kód a druhý zabrání opakování náhodných kódů z modelu Shortener. Chcete-li to provést, vytvořte soubor utils.py v aplikaci „urlshortener“.

touch utils.py

Uvnitř tohoto souboru použijeme funkci select z náhodného vestavěného modulu. To usnadňuje výběr náhodných znaků pro vytvoření kódu.

'''
Utilities for Shortener
'''
from django.conf import settings

from random import choice

from string import ascii_letters, digits

# Try to get the value from the settings module
SIZE = getattr(settings, "MAXIMUM_URL_CHARS", 7)

AVAIABLE_CHARS = ascii_letters + digits


def create_random_code(chars=AVAIABLE_CHARS):
    """
    Creates a random string with the predetermined size
    """
    return "".join(
        [choice(chars) for _ in range(SIZE)]
    )

Jak můžete vidět, tato funkce vrací náhodný řetězec délky určené v souboru nastavení nebo 7 ve výchozím nastavení. Používáte funkci getattr k získání proměnné z modulu nastavení, ale bez vyvolání chyby, pokud proměnná není zadána.

Pojďme si trochu spočítat. Pokud máme 7 míst, kde může být pro každé místo až 62 dostupných postav, je to možné permutace jsou:

Na základě těchto rychlých výpočtů lze tedy zkrácenou část vyplnit až 2,5 bilionu různých kódů. Takže můžeme zapomenout na vycházení z náhodných zkrácených URL.

I když může existovat tolik permutací, existuje malá pravděpodobnost získání opakovaných zkrácených částí. To je problém, protože jsme pole shortened_url nastavili jako jedinečné. Proto je následující funkce tak užitečná.

def create_shortened_url(model_instance):
    random_code = create_random_code()
    # Gets the model class

    model_class = model_instance.__class__

    if model_class.objects.filter(short_url=random_code).exists():
        # Run the function again
        return create_shortened_url(model_instance)

    return random_code

Podívejme se, co se tady děje. Funkce bere jako argument instanci modelu „Zkracovač“. Nejprve funkce vygeneruje náhodný kód pomocí create_random_code. Poté získá třídu modelu a zkontroluje, zda existuje nějaký jiný objekt, který má stejnou short_url. Pokud ano, spustí se sám ještě jednou, ale pokud je vše v pořádku, vrátí random_code.

Později budete interagovat s shellem, abyste se na tuto funkci podívali zblízka.

Po vytvoření užitkové funkce ji použijme k vytvoření náhodných kódů v modelu zkracovače.

Úprava způsobu uložení

Na konci třídy „Shortener“ se chystáte upravit metodu uložení modelu. Metoda uložení se volá pokaždé, když je objekt uložen do databáze, takže zde uvidíme, jak ji použít.

# Import the function used to create random codes
from .utils import create_shortened_url

# At the end of the  Shortener model
    def save(self, *args, **kwargs):

        # If the short url wasn't specified
        if not self.short_url:
            # We pass the model instance that is being saved
            self.short_url = create_shortened_url(self)

        super().save(*args, **kwargs)

Metoda ukládání se přepisuje, což znamená, že zavádíte nové funkce do již existující nadřazené metody. V podstatě to Djangovi říká, že pokaždé, když se uloží objekt „Shortener“ a short_url není specifikován, musí být vyplněn náhodným kódem.

Probíhající migrace

Nyní je čas provést a spustit migrace modelu Shortener. Chcete-li to provést, spusťte následující příkazy v kořenové složce projektu.

$ python manage.py makemigrations
Migrations for 'urlshortener':
  urlshortener/migrations/0001_initial.py
    - Create model Shortener

$ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions, urlshortener
Running migrations:
  ......
  # Apply the URL shortener migrations
  Applying urlshortener.0001_initial... OK

Prozatím se nemusíte starat o to, co jsou migrace. Jen mějte na paměti, že při spuštění těchto dvou příkazů Django vytvoří a databáze db.sqlite na základě vámi definovaných modelů.

Vytvořme nějaké objekty pomocí shellu Django.

$ python manage.py shell

>>> from urlshortener.models import Shortener
>>> s = Shortener(long_url="https://etechblog.cz.com")
>>> s.short_url
''
>>> s.save()
>>> s.short_url
'kdWFVIc'
>>> s.long_url
'https://etechblog.cz.com'
>>> print(s)
https://etechblog.cz.com to kdWFVIc

V podstatě tak budou fungovat všechny objekty zkracovače.

Psaní pohledů

Jak jsem řekl dříve, pohled je jednoduchá funkce, která přijímá požadavek a vrací odpověď. Pojďme se tedy podívat, jak vytvořit ahoj světový pohled.

Základní šablonová odpověď

Uvnitř souboru „urlshortener/views.py“ vytvořte funkci home_view. aa

'''
Shortener views
'''
from django.shortcuts import render, get_object_or_404 # We will use it later

from django.http import HttpResponse 

# Create your views here.

def home_view(request):
    return HttpResponse("Hello world")

Vrací jednoduchou zprávu „Ahoj světe“. Později uvidíte, jak to vypadá v prohlížeči. Nyní vytvořte „urls.py“, budou tam všechny vzory adres URL aplikace.

klepněte na urls.py

Přidejte následující kód.

'''
Urls for shortener app urlshortener/urls.py
'''

from django.urls import path

# Import the home view
from .views import home_view

appname = "shortener"

urlpatterns = [
    # Home view
    path("", home_view, name="home")
]

Proměnná appname deklaruje (jak její název napovídá) jmenný prostor aplikace urlshortener.

Rychlé vysvětlení, že dovážíme funkce cesty, která vrací prvek, který má být zahrnut do vzorů adres URL aplikace. Atribut name je jmenný prostor cesty, který lze v případě potřeby volat uvnitř šablon.

Nyní upravme celkové adresy URL projektu.

# config/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    
    # Shortener Urls
    path('', include('urlshortener.urls'))
]

Nyní spustíme server znovu.

python manage.py runserver

Pokud server spustíte, dostanete jednoduchou zprávu „Ahoj světe“. Je to proto, že do celkového projektu začleňujete vzory adres URL z aplikace pro zkracování adres URL.

Toto je pouze výchozí bod. Nyní je čas vytvořit formulář, který umožní uživateli vytvářet zkrácené adresy URL sám.

Vytváření formulářů

Ve společnosti Django, a formulář je jednoduchá třída, která umožňuje získat vstup od uživatele.

Chystáte se vytvořit soubor Forms.py. Je konvencí ukládat všechny formy aplikace do tohoto souboru.

cd urlshortener/
touch forms.py

Uvnitř tohoto souboru vytvoříte třídu „ShortenerForm“, která se rozšiřuje z „ModelForm“.

'''
Shortener Forms urlshortener/forms.py
'''

from django import forms

from .models import Shortener

class ShortenerForm(forms.ModelForm):
    
    long_url = forms.URLField(widget=forms.URLInput(
        attrs={"class": "form-control form-control-lg", "placeholder": "Your URL to shorten"}))
    
    class Meta:
        model = Shortener

        fields = ('long_url',)

Je to modelový formulář, protože jeho účelem je vytvořit objekt modelu z uživatelského vstupu. Používáme také argument widget, který nám umožňuje zadat atribut „class“ (třída v CSS, nikoli python). Je to proto, že později aplikaci stylizujeme pomocí bootstrapu.

Dokončení pohledů

Po sestavení formulářů je čas vytvořit konečnou obchodní logiku aplikace.

Přejděte do souboru views.py v aplikaci zkracovače a upravte zobrazení home_view. Můžete se podívat na Github repo v tuto chvíli získat představu o tom, jak vypadá struktura projektu.

Aplikace pro zkracování adres URL má dvě zobrazení:

  • Domovské zobrazení: Toto zobrazuje formulář zkracovače a novou adresu URL, pokud byl formulář již odeslán.
  • Zobrazení přesměrování: Toto přesměruje na dlouhou adresu URL a přidá 1 k následovaným časům.

    • Začněme domácím pohledem, který je nejsložitější. Budete muset importovat model a formulář Shortener. Stále používáte funkci, protože chci, abyste porozuměli veškerému datovému toku zobrazení. Také budete používat cestu pro šablonu (která ještě není vytvořena).

    Domácí pohled

    '''
Shortener views
'''
from django.shortcuts import render # We will use it later

from django.http import HttpResponse, Http404, HttpResponseRedirect


# Model
from .models import Shortener

# Custom form

from .forms import ShortenerForm

# Create your views here.

def home_view(request):
    
    template="urlshortener/home.html"

    
    context = {}

    # Empty form
    context['form'] = ShortenerForm()

    if request.method == 'GET':
        return render(request, template, context)

    elif request.method == 'POST':

        used_form = ShortenerForm(request.POST)

        if used_form.is_valid():
            
            shortened_object = used_form.save()

            new_url = request.build_absolute_uri('/') + shortened_object.short_url
            
            long_url = shortened_object.long_url 
             
            context['new_url']  = new_url
            context['long_url'] = long_url
             
            return render(request, template, context)

        context['errors'] = used_form.errors

        return render(request, template, context)

    Pohled je založen na dvou podmínkách:

  • Když se metoda HTTP rovná GET: Jako kontext předáváme pouze formulář Shortener používaný k vytváření objektů Shortener.
  • Když se metoda HTTP rovná POST: Stále předáváme formulář v kontextu, protože chceme, aby uživatel mohl zadat jinou adresu URL. Požadavek Post však předáváme jinému formuláři s názvem used_form.

    • Složitým způsobem, jak dynamicky získat úplnou adresu URL webu, je použití metody objektu požadavku build_absolute_uri .

    >>> print(request.build_absolute_uri('/'))
'https://localhost:8080/'

    Jako bezpečný způsob zpracování chybného požadavku (uživatel nezadal platnou adresu URL) získáme chyby formuláře, předáme je jako kontext a vykreslíme šablonu jako obvykle. Později uvidíte, jak implementovat zobrazení chyb v šabloně.

    Přesměrování pohledu

    Redirect_url_view je o něco jednodušší. Jedná se o detailní pohled, což znamená, že pohled pracuje pouze s objektem.

    Tato funkce bere jako parametry požadavek uživatele a zkrácenou_část URL. Není nutné uvádět typ požadavku, který dostáváme, protože v tomto zobrazení nepracujeme s formuláři.

    def redirect_url_view(request, shortened_part):

    try:
        shortener = Shortener.objects.get(short_url=shortened_part)

        shortener.times_followed += 1        

        shortener.save()
        
        return HttpResponseRedirect(shortener.long_url)
        
    except:
        raise Http404('Sorry this link is broken :(')

    Pohled chráníme příkazem try/except pro případ, že by zkrácená část nebyla v databázi nalezena. Pokud je objekt nalezen, přidá 1 do pole times_followed a přesměruje pomocí funkce HttpResponseRedirect na adresu URL webu odpovídající náhodnému kódu.

    Aktualizace adres URL

    Jakmile vytvoříte dvě zobrazení aplikace, je čas vytvořit vzory cílových adres URL tím, že zahrnete cestu k zobrazení redirect_url_view.

    Jako vždy začnete importováním pohledů a poté vytvořením funkce cesty a předáním jako argumenty:

    • Cesta URL
    • Pohled ukazující na cestu
    • Název cesty
    '''
Urls for shortener app urlshortener/urls.py
'''

from django.urls import path

# Import the home view
from .views import home_view, redirect_url_view

appname = "shortener"

urlpatterns = [
    # Home view
    path('', home_view, name="home"),
    path('<str:shortened_part>', redirect_url_view, name="redirect"),
]

    S tímto nastavením adresy URL vypadá směrování aplikace takto.

    • localhost:8000/: Home view
    • localhost:8000/URL-code: Přesměrování na dlouhou URL

    Vytváření šablon

    Už jste skoro tam. Jediná věc, která vás dělí od vytvoření této aplikace, je uživatelské rozhraní. K tomu používáme šablony Django.

    Šablony se používají k vykreslení čistého rozhraní pro uživatele aplikace. Tyto soubory jsou vytvářeny uvnitř aplikace ve dvousložkové struktuře ve tvaru: „templates/appname“

    # urlshortener directory
mkdir -p templates/urlshortener/

    Poznámka: Struktura dvojité složky a jazyk šablony Django jsou mimo rámec tohoto tutoriálu, ale můžete si o nich přečíst v oficiální dokumentace.

    Základní šablona

    Django umožňuje dědění šablony. To znamená, že můžeme mít základní šablonu a rozšířit ji za účelem dodržení principu DRY (Neopakuj se).

    cd templates/urlshortener
touch base.html

    Soubor base.html je konvence a znamená, že každá další šablona v aplikaci musí být rozšířením této šablony.

    <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Django Url shortener</title>

    <link
      href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
      rel="stylesheet"
      integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0"
      crossorigin="anonymous"
    />

    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css"
      integrity="sha512-iBBXm8fW90+nuLcSKlbmrPcLa0OT92xO1BIsZ+ywDWZCvqsWgccV3gFoRBv0z+8dLJgyAHIhR35VZc2oM/gI1w=="
      crossorigin="anonymous"
    />
  </head>
  <body>
   
    {% block body %} 
   
   
    
    {% endblock body %}
    
    <script
      src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"
      integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8"
      crossorigin="anonymous"
    ></script>
  </body>
</html>

    Použijeme bootstrap CDN, abychom vytvořili rychlé a pěkné rozhraní, aniž bychom potřebovali soubory CSS nebo javascript.

    Pokud se chcete hlouběji dozvědět o značkách DTL, můžete to udělat pomocí oficiální dokumenty.

    Domovská šablona

    Domovská šablona, ​​odvozená ze souboru base.html. To znamená, že tato šablona obsahuje veškerý HTML z nadřazeného souboru.

    {% extends 'urlshortener/base.html' %} 

{% block body %}

<div class="container">
  <div class="card mt-5">
    <div class="card-header text-center py-3">
      <h1>URL Shortner Application <i class="fas fa-link px-2"></i></h1>
    </div>
    <div class="px-3 py-4">
      <form action="" method="POST">
        {% csrf_token %}
        <div class="row g-1">
          <div class="col-10">{{form.long_url}}</div>
          <div class="col-2">
            <button class="btn btn-success btn-lg w-100" type="submit">
              Shorten
            </button>
          </div>
        </div>
      </form>
    </div>
  </div>
  {% if errors %}
  <div class="alert alert-danger mt-4" role="alert">
    <p>{{errors}}</p>
  </div>
  {% endif %}

  {% if new_url %}

  <div class="mx-auto text-center mt-5">
    <h2 class="text-danger">Your shortened Url</h2>
    <p>You can copy the Link below and share it with your friends</p>
    <p class="">{{new_url}}</p>
    <p><span class="text-danger">Previous URL:</span> {{long_url}}</p>
  </div>
  {% endif %}
</div>
{% endblock body %}

    Rychle vysvětlím datový tok této šablony:

    • Zobrazí se formulář Shortener. Uvnitř crsf token (Bezpečnostní důvody) a zobrazí se pouze dlouhé pole URL formuláře. Pamatujte, že toto pole má třídu CSS, „form-control form-control-lg“, protože jsme ji nastavili ve formuláři.
    • Pokud jsou nalezeny nějaké chyby, ukažte je
    • Pokud je operace POST úspěšná, zobrazí se nová adresa URL.

    Konečná aplikace

    Gratulujeme! 🎉. S Django jste vytvořili kompletní funkční aplikaci pro zkracování adres URL.

    Zde je několik snímků obrazovky, jak aplikace vypadá.

    Získejte pouze:

    Chyba při zkracování adresy URL:

    Úspěšná zkrácená adresa URL:

    URL přesměrováno:

    Co si myslíte o vystavení ukázky této aplikace pro zkracování adres URL někomu? Podívejte se, jak vystavit aplikaci Django Demo na internetu.

    Výzva 🔥

    Pokud se cítíte dobře se svými dovednostmi Django, proč si nezacvičit s výzvou?.

    Naklonujte kód této aplikace a vytvořte si autentizační systém, kde pouze registrovaní uživatelé mohou zkracovat své URL.

    Až budete hotovi, pošlete žádost o stažení a odešlete mi ping Cvrlikání ukázat své úspěchy.

    Zabalení

    Dosáhli jste konce tohoto tutoriálu. Věřte tomu nebo ne, právě jste zkontrolovali všechny hlavní aspekty vytváření projektu Django. Doufám, že jste to považovali za velmi užitečné.

    V tomto tutoriálu:

    • Dozvěděli jste se o pracovním postupu vytváření aplikace Django.
    • Vytvořil projekt životopisu
    • Pochopil rozdíly a strukturu projektů Django a aplikací Django.
    • Objevil vzor MVT.
    • Vytvořené základní pohledy funkcí
    • Použil Django ORM (Object Relational Mapper) k vytvoření jednoduchých modelů

    To je vše, je toho hodně k pokrytí Webový rámec Djangotakže nás kontaktujte pro další úžasné návody.