Cel mai bun mod de a învăța Django, sau orice abilitate, este prin aplicarea cunoștințelor pe care le aveți prin crearea de proiecte funcționale.
Django este cel mai folosit cadru de dezvoltare web Python. Caracteristicile sale încorporate și cantitatea extinsă de pachete terțe l-au făcut unul dintre cele mai iubite cadre web din întreaga lume.
Este rapid, fiabil și are o mulțime de funcții încorporate. De exemplu, un sistem de autentificare a orificiilor, care vă permite să vă concentrați asupra principalelor caracteristici ale aplicației dvs. De asemenea, puteți instala pachete externe pentru a îndeplini sarcini și mai complexe, cum ar fi Django-allauth, care vă permite să înregistrați utilizatorii cu conturile lor sociale.
Dar haideți să expunem câteva fapte. Django este un cadru atât de mare, care uneori este dificil să începeți cu el.
Așa că astăzi veți construi de la zero o aplicație Django complet funcțională.
Până la sfârșitul acestui tutorial, veți:
- Ați scris o aplicație de scurtare a adreselor URL
- Înțelegeți modelul Django MVT
- Ați învățat fluxul de lucru al creării unui proiect
Cuprins
Cerinte obligatorii de inceput
Toate cerințele de mai jos sunt opționale și vă vor ajuta să urmați tutorialul. Dar dacă nu aveți experiență cu niciuna dintre acestea, nu vă faceți griji. Cel mai important pas este primul.
- Înțelegerea de bază a comenzilor UNIX (ls, cd, rm, touch)
- Înțelegerea de bază a claselor și funcțiilor Python
- Python instalat pe computer (Poate evident, dar a trebuit să-l includ)
- Ar fi grozav dacă ai construit deja ceva cu Django
Tot codul de lucru va fi disponibil pe aceasta Repoziție Github.
Acum că aveți conceptele anterioare clare, să intrăm în chestiune.
Declarație de proiect
În acest tutorial, veți construi un dispozitiv de scurtare a adreselor URL. Practic, un URL shortener este un serviciu care ia un URL lung și îl transformă într-unul compact.
De exemplu, dacă doriți să distribuiți un tweet și doriți să includeți un link către site-ul dvs. web, dar vă confruntați cu limita de caractere, puteți utiliza un dispozitiv de scurtare a adreselor URL.
Să vedem cu o grafică.
După cum puteți vedea, dispozitivul de scurtare URL primește o adresă URL lungă și returnează una scurtă. Exact asta veți construi astăzi.
Cu acest proiect, veți exersa utilizarea modelului MVT, veți învăța elementele de bază ale designului bazei de date cu modelele Django și veți învăța cum să afișați informații utilizatorului prin vizualizări, adrese URL și șabloane.
Structura unui proiect Django
Practic, un site web Django este construit pe un singur proiect și mai multe aplicații separate. Fiecare dintre aceste aplicații are o funcționalitate specifică și poate funcționa de la sine.
Să ne imaginăm o aplicație web complexă ca Stackoverflow. Funcționalitatea sa se bazează pe două aspecte principale.
- Gestionarea utilizatorilor: Autentificare, Deconectare, Reputație, Permisiuni
- Forum: Întrebări, răspunsuri, etichete, filtre
Deci, urmând structura site-ului web Django, proiectul va fi numit StackOverflow, care are două aplicații principale. Aplicația utilizatorilor și aplicația forum.
Fiecare dintre aceste aplicații are funcționalitate autonomă. Asta înseamnă că ambele conțin tot codul de care au nevoie pentru a funcționa corect.
Acestea includ modele (structura bazei de date), vizualizări (cereri și răspunsuri), modele URL specifice și, desigur, șabloane și fișiere statice (imagini, CSS, JavaScript). Aceasta înseamnă că orice aplicație Django poate fi reutilizată, deoarece poate funcționa de la sine.
Scurtarea, un proiect se referă la un set de configurații și aplicații care sunt menite să construiască o aplicație web. Pe de altă parte, o aplicație Django face parte dintr-un proiect, care este autonom (are tot ce trebuie să funcționeze), iar scopul său este de a efectua o anumită operație.
Configurați un proiect Django
În această secțiune, veți configura un proiect Django. În acest scop, veți folosi diferite instrumente, cum ar fi un mediu virtual, pentru a organiza dependențele Python și cele mai importante script-uri Django. Django-admin și manage.py
Mediu virtual
Întotdeauna recomand să lucrezi cu medii virtuale când construiești aplicații cu Django. Este cel mai eficient mod de a menține un anumit set de dependențe. Dar scopul său principal este de a izola pachetele de dezvoltare de cele globale.
Deci, haideți să creăm un mediu virtual cu comanda de formular încorporată python.
Notă: această metodă necesită Python 3.6 sau versiuni mai noi pentru a funcționa.
python -m venv .venv
Această comandă folosește comanda python -m sau python –mod. În principiu, rulează un modul sau o bibliotecă, ca script. Conform sensului acestei comenzi, venv este biblioteca pe care o rulăm, iar .venv se referă la numele mediului virtual pe care dorim să-l creăm.
Deci, într-un limbaj simplu, această comandă înseamnă.
Bună Python, rulați ca script biblioteca încorporată venv și creați un nume virtualenv .venv
Acum, este timpul să activăm mediul virtual pe care tocmai l-am creat, cu următoarea comandă.
source .venv/bin/activate
Pentru a afirma că nu aveți niciun pachet instalat în noul venv, rulați.
pip freeze
Dacă ați activat corect mediul virtual, nu veți obține niciun rezultat. Asta pentru că încă nu am instalat nimic.
Să intrăm în Django
Pentru a crea aplicația noastră de scurtare URL, vom începe prin a instala pachetul Django. Django este un pachet terță parte, de aceea trebuie să-l instalăm cu 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
Notă: Amintiți-vă că $ nu este altceva decât simbolul dvs. shell.
Pentru a verifica dacă instalarea a mers corect, verificăm din nou pachetele instalate ale venv-ului nostru.
$ pip freeze asgiref==3.3.4 Django==3.2.1 pytz==2021.1 sqlparse==0.4.1
Nu vă faceți griji dacă versiunile pe care le obțineți sunt diferite de ale mele. Dacă Django rămâne în versiunea 3.x, puteți continua fără nicio problemă.
Pornirea unui proiect Django
Odată ce ați instalat Django, este timpul să creați structura site-ului web de scurtare URL. Îți amintești ce este un proiect Django? Să creăm unul rulând următoarea comandă.
django-admin startproject config
Explicând totul despre această comandă, django-admin este un utilitar de linie de comandă care efectuează toate sarcinile necesare pentru a crea un proiect Django. Partea „startproject” este comanda rulată de utilitarul Django-admin, iar config este numele proiectului pe care îl vom crea.
Este important de subliniat că config poate fi orice nume doriți. Motivul pentru care folosesc config ca nume al acestui proiect este doar din cauza confortului. Este plăcut să comutați între proiecte și să aveți în continuare aceeași convenție de denumire. Așa că nu vă fie teamă să folosiți alte nume de proiecte oricând doriți.
După cum puteți observa, acum aveți un config/ folder și în interior, există multe fișiere. Mai târziu vom vedea structura fișierului proiectului. Deocamdată, să intrăm în directorul proiectului și să rulăm serverul local.
cd config/
Cel mai important fișier pe care îl veți folosi este scriptul manage.py. Are aceeași funcționalitate ca django-admin, dar principalul avantaj al utilizării este că vă permite să gestionați setările atunci când rulați proiectul.
Acum să vedem dacă totul funcționează corect.
python manage.py runserver
Crearea aplicației pentru scurtarea adreselor URL
Este timpul să creați aplicația principală a proiectului. Veți folosi fișierul manage.py pentru a îndeplini această sarcină.
python manage.py startapp urlshortener
Aceasta creează o aplicație Django, cu numele urlshortener. Dacă rulați copac comanda, veți obține așa ceva.
.
├── 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
Să clarificăm diferitele fișiere create până în acest moment. „config” este numele proiectului nostru și este numit așa doar pentru convenție. În interiorul config, obțineți settings.py, este fișierul în care setați toate setările proiectului. urls.py este configurația generală a adreselor URL din cadrul proiectului. Acesta definește căile URL ale tuturor aplicațiilor din interiorul proiectului.
Nu vă faceți griji prea mult cu privire la fișierele asgi.py și wsgi.py. Acestea sunt fișiere care vă permit să vă configurați aplicația în implementare.
manage.py este scriptul python care vă permite să rulați toate comenzile disponibile ale Django-admin.
Aruncând o privire în urlshortener, care este numele aplicației pe care tocmai ați creat-o, puteți observa că există un folder ciudat numit „migrations/” și alte fișiere care sunt cruciale pentru logica oricărei aplicații.
apps.py este locul unde se află configurația aplicației. De obicei, nu te încurci cu asta, cu excepția faptului că faci lucruri destul de avansate.
admin.py este locul în care vă înregistrați modelele pentru a le face vizibile în panoul de administrare Django.
models.py este cel mai important. În cadrul acestui modul, trebuie să definiți modelele, care (spunând vag) sunt modul în care sunt stocate datele. Veți auzi mai multe despre modele mai târziu.
migrations/ este folderul în care sunt stocate migrațiile Django. Vom arunca o privire în profunzime mai târziu.
tests.py este fișierul în care sunt stocate testele. Nu vom acoperi testarea în acest tutorial.
views.py este fișierul care stochează vizualizări. Practic, definește modul în care utilizatorul va interacționa cu toate aspectele aplicației dvs.
Instalarea unei aplicații Django
Înainte de a continua, deschideți fișierul settings.py și modificați variabila INSTALLED_APPS adăugând aplicația 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',
]
Acesta este un proces de rutină atunci când creați o aplicație. Așa că de fiecare dată când o faci, nu uita să-l instalezi în setările proiectului.
Înțelegerea modelului MVT
Modelul Model, View, Template este modelul de proiectare software pe care dezvoltatorii Django îl folosesc pentru a crea aplicații web.
Se bazează pe 3 concepte principale. Model (date), Vizualizare (Interacțiunea utilizatorului cu datele), Șablon (Cum văd utilizatorii datele).
Modelele sunt clase Python, care definesc toate câmpurile și comportamentul datelor pe care sunteți dispus să le stocați. În mod normal, fiecare model se referă la un tabel unic din baza de date
Vizualizările, în expresia lor cea mai simplă, sunt apelabile care preiau o solicitare de la utilizator și generează un răspuns. Între acest proces apare logica afacerii. Știu că „logica de afaceri” este un concept destul de obscur, așa că permiteți-mi să explic exact ce este. Logica de afaceri este modul în care datele sunt create, stocate și șterse, asta-i tot.
În cele din urmă, șabloanele sunt documente text (de obicei Html) care sunt afișate utilizatorilor. Scopul său este de a prezenta datele cât mai curate posibil. Django încorporează un mini-limbaj numit Limbajul șablonului Django (DTL) care vă permite să încorporați o parte din puterea lui python în documentele text.
Creați modelul Shortener
Odată ce ați înțeles rapid modelul MVT, să trecem la crearea de la zero a dispozitivului de scurtare URL Django.
Mai întâi de toate, să definim modelul mai scurt în interiorul fișierului 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}'
Știu. Este o clasă destul de uriașă, cu o mulțime de lucruri ciudate, dar nu disperați. Voi merge pas cu pas asupra fiecărui lucru important.
Explicația modelului
În primul rând, importăm modulul de modele. Acest modul conține toate funcționalitățile de care avem nevoie pentru a crea un model Django.
Aruncând o privire la modelul „Shortener”, primul lucru de remarcat este că extinde modelele.Model. De fapt, orice model din orice aplicație Django trebuie să fie o subclasă a modele.Model clasă.
Apoi definim toate câmpurile pe care modelul le va avea în baza de date. Câmpul „creat” este data și ora la care este creată legătura scurtată, prin urmare folosim DateTimeField pentru a crea acest tip de funcționalitate. Folosim argumentul auto_now_add=True deoarece dorim ca câmpul să fie modificat numai atunci când este creată instanța.
Al doilea câmp times_followed se referă la perioadele în care URL-ul scurtat a fost utilizat. Este un PositiveIntegerField și specificăm valoarea implicită de zero. Aceasta înseamnă că de fiecare dată când o instanță a creat câmpul times_followed, Django va completa acel câmp cu 0.
Pe de altă parte, long_url se referă la adresa URL introdusă de utilizator. Este un URLField, deoarece dorim ca utilizatorul să introducă doar caractere din formularul: http://yoursite.com.
Ultimul câmp este short_url și are detalii interesante. Precizăm că poate avea doar 15 caractere, trebuie să fie unic, ceea ce înseamnă că nu pot exista elemente repetate în acel câmp. În cele din urmă, indicăm că poate fi lăsat necompletat, ceea ce înseamnă că atunci când lucrează cu formulare, utilizatorii nu vor trebui să scrie propriul cod de scurtare.
Clasa interioară Meta, ne spune cum trebuie să se comporte clasa și setăm ca ordonarea (apelarea Shortener.objects.all()) a obiectelor mai scurte să fie discriminată de cele mai recente.
Metoda __str__ spune cum trebuie tipărit modelul. Deci, dacă avem un obiect cu long_url = „https://tipstrick.ro.com/” și partea scurtată „123456”, și îl imprimăm.
https://tipstrick.ro.com/ to 123456
Acum este timpul să căutați o modalitate de a salva linkul scurt într-un mod aleatoriu.
Crearea unei funcționalități de scurtare
Vom crea 2 funcții personalizate. Primul va genera un cod aleator, iar al doilea va preveni obținerea de coduri aleatoare repetate din modelul Shortener. Pentru a face acest lucru, creați un fișier utils.py în aplicația „urlshortener”.
touch utils.py
În interiorul acestui fișier, vom folosi funcția de alegere din modulul încorporat aleatoriu. Acest lucru facilitează sarcina de a alege caractere aleatorii pentru a crea codul.
'''
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)]
)
După cum puteți vedea, această funcție returnează un șir aleatoriu de lungimea specificată în fișierul de setări sau 7 în mod implicit. Utilizați funcția getattr pentru a obține o variabilă din modulul de setări, dar fără a arunca o eroare dacă variabila nu este specificată.
Hai să facem niște matematică. Dacă avem 7 locuri în care pot fi până la 62 de caractere disponibile pentru fiecare loc, este posibil permutări sunteți:
Deci, pe baza acestor calcule rapide, partea scurtată poate fi completată cu până la 2,5 trilioane de coduri diferite. Așa că putem uita să ieșim din adresele URL scurtate aleatoriu.
Deși pot exista atât de multe permutări, există o mică probabilitate de a obține părți scurtate repetate. Aceasta este o problemă, deoarece am configurat câmpul shortened_url să fie unic. De aceea, următoarea funcție este atât de utilă.
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
Să vedem ce se întâmplă aici. Funcția ia ca argument o instanță de model „Scurtare”. În primul rând, funcția generează un cod aleatoriu folosind create_random_code. Apoi primește clasa modelului și verifică dacă există alt obiect care are același short_url. Dacă o face, rulează singur încă o dată, dar dacă totul este bine, returnează codul_aleatoriu.
Mai târziu vei interacționa cu shell-ul, pentru a arunca o privire asupra acestei funcții îndeaproape.
După crearea funcției de utilitate, să o folosim pentru a crea coduri aleatorii în modelul de scurtator.
Modificarea metodei de salvare
La sfârșitul clasei „Shortener”, veți modifica metoda de salvare a modelului. Metoda de salvare este apelată de fiecare dată când un obiect este salvat în baza de date, așa că vom vedea cum să-l folosim aici.
# 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 de salvare este suprascrisă, ceea ce înseamnă că introduceți o nouă funcționalitate unei metode părinte preexistente. Practic îi spune lui Django că de fiecare dată când un obiect „Scurtare” este salvat și short_url-ul nu este specificat, acesta trebuie completat cu un cod aleatoriu.
Rularea migrațiilor
Acum este timpul să faceți și să rulați migrațiile modelului Shortener. Pentru a face acest lucru, rulați următoarele comenzi în folderul proiectului rădăcină.
$ 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
Deocamdată, nu trebuie să vă faceți griji despre ce sunt migrațiile. Nu uitați că atunci când rulați aceste două comenzi, Django creează un baza de date db.sqlite fișier, pe baza modelelor pe care le-ați definit.
Să creăm câteva obiecte cu shell-ul Django.
$ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://tipstrick.ro.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://tipstrick.ro.com' >>> print(s) https://tipstrick.ro.com to kdWFVIc
Cam așa vor funcționa toate obiectele mai scurte.
Vederi de scriere
După cum am spus mai înainte, o vizualizare este o funcție simplă care preia o solicitare și returnează un răspuns. Așadar, să vedem cum să creăm o viziune bună asupra lumii.
Răspuns șablon de bază
În interiorul fișierului „urlshortener/views.py” creați o funcție 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")
Acesta returnează un mesaj simplu „Bună lume”. Mai târziu vei vedea cum arată în browser. Acum creați un „urls.py”, acolo vor sta toate modelele URL ale aplicației.
atingeți urls.py
Adăugați următorul cod.
'''
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")
]
Variabila appname declară (după cum sugerează și numele) spația dintre nume a aplicației urlshortener.
Explicând rapid că importăm funcția de cale, care returnează un element de inclus în urlpattern-urile aplicației. Atributul nume este spațiul de nume al căii, care poate fi numit în interiorul șabloanelor dacă este necesar.
Acum, să modificăm adresele URL generale ale proiectului.
# 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'))
]
Acum să rulăm din nou serverul.
python manage.py runserver
Dacă rulați serverul, veți primi un mesaj simplu „Bună ziua, lume”. Acest lucru se datorează faptului că includeți modelele URL din aplicația de scurtare a adreselor URL în proiectul general.
Acesta este doar un punct de plecare. Acum este timpul să creați un formular pentru a permite utilizatorului să creeze singur adrese URL scurtate.
Crearea de formulare
În Django, a formă este o clasă simplă care permite obținerea de informații de la Utilizator.
Veți crea un fișier forms.py. Este o convenție de a stoca toate formele aplicației în acel fișier.
cd urlshortener/ touch forms.py
În interiorul acelui fișier veți crea o clasă „ShortenerForm” care se extinde de la „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',)
Este o formă de model, deoarece scopul său este de a crea un obiect model din intrarea utilizatorului. De asemenea, folosim argumentul widget, care ne permite să specificăm atributul „class” (clasă în CSS, nu python). Acest lucru se datorează faptului că vom stiliza aplicația cu bootstrap mai târziu.
Terminarea vederilor
După construirea formularelor, este timpul să creăm logica finală de afaceri a aplicației.
Navigați la fișierul views.py din aplicația de scurtare și modificați vizualizarea home_view. Puteți verifica Repoziție Github în acest moment pentru a vă face o idee despre cum arată structura proiectului.
Există două vizualizări pentru aplicația de scurtare a adreselor URL:
Să începem cu vizualizarea acasă care este cea mai complexă. Va trebui să importați modelul și formularul Shortenerului. Încă folosiți o funcție, deoarece vreau să înțelegeți tot fluxul de date al vizualizării. De asemenea, veți folosi calea pentru un șablon (care nu este încă creat).
Vedere acasă
'''
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)
Vederea se bazează pe două condiționale:
O modalitate dificilă de a obține în mod dinamic adresa URL completă a site-ului este utilizarea metodei obiectului de solicitare build_absolute_uri .
>>> print(request.build_absolute_uri('/'))
'https://localhost:8080/'
Ca modalitate sigură de procesare a unei cereri greșite (Utilizatorul nu a introdus o adresă URL validă), primim erorile de formular, le transmitem ca context și redăm șablonul ca normal. Mai târziu, veți vedea cum să implementați afișarea erorilor în șablon.
Vizualizare de redirecționare
Redirect_url_view , este puțin mai simplu. Este o vedere detaliată, ceea ce înseamnă că vizualizarea funcționează numai cu un obiect.
Această funcție ia ca parametri, cererea utilizatorului și shortened_part-ul URL. Nu este necesar să afirmăm tipul de solicitare pe care o primim, deoarece nu lucrăm cu formulare în această vedere.
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 :(')
Protejăm vizualizarea cu o declarație try/except, în cazul în care partea scurtată nu este găsită în baza de date. Dacă obiectul este găsit, acesta adaugă 1 la câmpul times_followed și redirecționează cu funcția HttpResponseRedirect către adresa URL a site-ului corespunzătoare codului aleatoriu.
Actualizarea adreselor URL
După ce ați creat cele două vizualizări ale aplicației, este timpul să creați modelele URL finale, incluzând calea către redirect_url_view.
Ca întotdeauna, începeți prin a importa vizualizările, apoi creați o funcție de cale și treceți ca argumente:
- Ruta URL
- Vederea îndreptată spre potecă
- Numele căii
'''
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"),
]
Cu această configurare URL, rutarea aplicației arată astfel.
- localhost:8000/: Vedere de pornire
- localhost:8000/URL-code: redirecționare către adresa URL lungă
Crearea șabloanelor
Ești aproape acolo. Singurul lucru care vă separă de a crea această aplicație este interfața cu utilizatorul. Pentru asta, folosim șabloane Django.
Șabloanele sunt folosite pentru a reda o interfață curată utilizatorului aplicației. Aceste fișiere sunt create în interiorul aplicației într-o structură dublă de foldere de forma: „șabloane/nume aplicație”
# urlshortener directory mkdir -p templates/urlshortener/
Notă: Structura de foldere duble și limbajul șablonului Django depășesc domeniul de aplicare al acestui tutorial, dar puteți citi despre ele în documentație oficială.
Șablon de bază
Django permite moștenirea șablonului. Aceasta înseamnă că putem avea un șablon de bază și îl putem extinde cu scopul de a urma principiul DRY (Nu te repeta).
cd templates/urlshortener touch base.html
Fișierul base.html este o convenție și înseamnă că orice alt șablon din aplicație trebuie să fie o extensie a acestuia.
<!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>
Vom folosi CDN-ul bootstrap, pentru a face o interfață rapidă și drăguță fără a avea nevoie de fișiere CSS sau javascript.
Dacă doriți să aflați profund despre etichetele DTL, puteți face acest lucru cu documente oficiale.
Șablon de acasă
Șablonul de pornire, inerente din fișierul base.html. Aceasta înseamnă că acest șablon include tot codul HTML din fișierul părinte.
{% 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 %}
Voi explica rapid fluxul de date al acestui șablon:
- Este afișat formularul Shortener. În interiorul jeton crsf este setat (Motive de securitate) și este afișat numai câmpul URL lung al formularului. Amintiți-vă că acest câmp are clasa CSS, „form-control form-control-lg”, deoarece am setat-o în formular.
- Dacă se găsesc erori, afișați-le
- Dacă operațiunea POST reușește, se afișează noua adresă URL.
Aplicație finală
Felicitări! 🎉. Ați creat o aplicație completă funcțională de scurtare a adreselor URL cu Django.
Iată câteva capturi de ecran despre cum arată aplicația.
Obțineți doar:
Eroare la scurtarea adresei URL:
Adresă URL scurtată cu succes:
URL redirecționat:
Ce părere aveți despre expunerea cuiva a unei demonstrații a acestei aplicații de scurtare a adreselor URL? Verificați cum să expuneți o aplicație Demo Django la internet.
Provocare 🔥
Dacă te simți confortabil cu abilitățile tale Django, de ce să nu exersezi cu o provocare?.
Clonează codul acestei aplicații și creează un sistem de autentificare, în care doar utilizatorii înregistrați își pot scurta adresele URL.
Când ați terminat, trimiteți o cerere de extragere și trimiteți-mi un ping Stare de nervozitate pentru a vă prezenta realizările.
Încheierea
Ați ajuns la sfârșitul acestui tutorial. Credeți sau nu, tocmai ați trecut în revistă toate aspectele principale ale creării unui proiect Django. Sper că l-ai găsit extrem de util.
În acest tutorial:
- Am aflat despre fluxul de lucru al creării unei aplicații Django.
- A creat un proiect de CV
- A înțeles diferențele și structura proiectelor Django și a aplicațiilor Django.
- A descoperit modelul MVT.
- Vizualizări de bază ale funcției create
- Am folosit Django ORM (Object Relational Mapper) pentru a crea modele simple
Asta e tot, sunt multe de acoperit cu Cadru web Djangoașa că păstrați legătura pentru mai multe tutoriale uimitoare.