Ceļvedis URL saīsināšanas lietotnes izveidei, izmantojot Django

Labākais veids, kā apgūt Django vai jebkuru prasmi, ir pielietot iegūtās zināšanas, veidojot funkcionālus projektus.

Django ir visvairāk izmantotais Python tīmekļa izstrādes ietvars. Tā iebūvētās funkcijas un plašais trešo pušu pakotņu daudzums ir padarījis to par vienu no iecienītākajām tīmekļa sistēmām visā pasaulē.

Tas ir ātrs, uzticams un tajā ir daudz iebūvētu funkciju. Piemēram, caurumu autentifikācijas sistēma, kas ļauj koncentrēties uz jūsu lietotnes galvenajām funkcijām. Varat arī instalēt ārējās pakotnes, lai veiktu vēl sarežģītākus uzdevumus, piemēram, Django-allauth, kas ļauj reģistrēt lietotājus ar viņu sociālajiem kontiem.

Bet atklāsim dažus faktus. Django ir tik milzīgs ietvars, ka dažreiz ir grūti sākt ar to.

Tāpēc šodien jūs gatavojaties no nulles izveidot pilnīgi funkcionālu Django lietojumprogrammu.

Līdz šīs apmācības beigām jūs:

  • Esat uzrakstījis URL saīsināšanas lietotni
  • Izprotiet Django MVT modeli
  • Ir apguvuši projekta izveides darbplūsmu

Iepriekšējās prasības

Visas tālāk minētās prasības nav obligātas, un tās palīdzēs jums sekot līdzi apmācībai. Bet, ja jums nav pieredzes ar kādu no šiem, neuztraucieties. Vissvarīgākais solis ir pirmais.

  • Pamata izpratne par UNIX komandām (ls, cd, rm, touch)
  • Pamata izpratne par Python klasēm un funkcijām
  • Python instalēta jūsu datorā (varbūt acīmredzami, bet man tas bija jāiekļauj)
  • Būtu lieliski, ja jūs jau esat kaut ko uzbūvējis ar Django

Šeit būs pieejams viss darba kods Github repo.

Tagad, kad jums ir pilnīgi skaidri iepriekšējie jēdzieni, pievērsīsimies jautājumam.

Projekta paziņojums

Šajā apmācībā jūs gatavojaties izveidot URL saīsinātāju. Būtībā URL saīsinātājs ir pakalpojums, kas aizņem garu URL un pārvērš to par kompaktu.

Piemēram, ja vēlaties kopīgot tvītu un iekļaut saiti uz savu vietni, taču jums ir noteikts rakstzīmju skaita ierobežojums, varat izmantot URL saīsinātāju.

Apskatīsim to ar grafiku.

Kā redzat, URL saīsinātājs iegūst garu URL un atgriež īsu. Tas ir tieši tas, ko jūs gatavojaties veidot šodien.

Šajā projektā jūs praktizēsiet MVT modeļa izmantošanu, apgūsit datu bāzes dizaina pamatus ar Django modeļiem un uzzināsit, kā parādīt informāciju lietotājam, izmantojot skatus, URL un veidnes.

Django projekta struktūra

Būtībā Django vietne ir veidota, pamatojoties uz vienu projektu un vairākām atdalītām lietotnēm. Katrai no šīm lietotnēm ir noteikta funkcionalitāte, un tā var darboties pati par sevi.

Iedomāsimies tādu sarežģītu tīmekļa lietojumprogrammu kā Stackoverflow. Tās funkcionalitāte ir balstīta uz diviem galvenajiem aspektiem.

  • Lietotāju pārvaldība: Pierakstīšanās, Atteikšanās, Reputācija, Atļaujas
  • Forums: jautājumi, atbildes, atzīmes, filtri

Tātad, ievērojot Django vietnes struktūru, projekts tiks nosaukts par StackOverflow, kurā ir divas galvenās lietotnes. Lietotāju lietotne un foruma lietotne.

Katrai no šīm lietotnēm ir atsevišķa funkcionalitāte. Tas nozīmē, ka abi satur visu kodu, kas tiem nepieciešams, lai tie darbotos pareizi.

Tas ietver modeļus (datu bāzes struktūru), skatus (pieprasījumus un atbildes), īpašus URL modeļus un, protams, veidnes un statiskus failus (attēli, CSS, JavaScript). Tas nozīmē, ka jebkuru Django lietotni var izmantot atkārtoti, jo tās var darboties pašas.

Saīsinot, projekts attiecas uz konfigurāciju un lietotņu kopu, kas paredzēta tīmekļa lietojumprogrammas izveidei. No otras puses, Django lietotne ir daļa no projekta, kas ir autonoma (ir viss nepieciešamais darbam), un tās mērķis ir veikt konkrētu darbību.

Uzstādiet Django projektu

Šajā sadaļā jūs gatavojaties iestatīt Django projektu. Šim nolūkam jūs izmantosit dažādus rīkus, piemēram, virtuālo vidi, lai organizētu Python atkarības un svarīgākos Django skriptus. Django-admin un manage.py

Virtuālā vide

Es vienmēr iesaku strādāt ar virtuālās vides veidojot lietotnes ar Django. Tas ir visefektīvākais veids, kā uzturēt noteiktu atkarību kopu. Bet tā galvenais mērķis ir izolēt izstrādes pakotnes no globālajām.

Tātad, izveidosim virtuālo vidi ar python iebūvēto formu komandu.

Piezīme. Lai šī metode darbotos, nepieciešama Python 3.6 vai jaunāka versija.

python -m venv .venv

Šī komanda izmanto komandu python -m vai python -mod. Būtībā tas palaiž moduli vai bibliotēku kā skriptu. Saskaņā ar šīs komandas nozīmi venv ir bibliotēka, kuru mēs palaižam, un .venv attiecas uz tās virtuālās vides nosaukumu, kuru vēlamies izveidot.

Tātad vienkāršā valodā šī komanda nozīmē.

Hei Python, palaidiet kā skriptu iebūvēto bibliotēku venv un izveidojiet virtualenv nosaukumu .venv

Tagad ir pienācis laiks aktivizēt tikko izveidoto virtuālo vidi ar šādu komandu.

source .venv/bin/activate

Lai apstiprinātu, ka jaunajā venv nav instalēta nulle pakotņu, palaidiet.

pip freeze

Ja virtuālo vidi aktivizējāt pareizi, jūs nesaņemsit nekādu izvadi. Tas ir tāpēc, ka mēs vēl neko neesam instalējuši.

Ieejam Django

Lai izveidotu URL saīsināšanas lietojumprogrammu, mēs sāksim ar Django pakotnes instalēšanu. Django ir trešās puses pakotne, tāpēc mums tā jāinstalē, izmantojot 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

Piezīme: Atcerieties, ka $ nav nekas cits kā jūsu apvalka simbols.

Lai pārbaudītu, vai instalēšana noritēja pareizi, mēs vēlreiz pārbaudām mūsu venv instalētās pakotnes.

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

Neuztraucieties, ja jūsu iegūtās versijas atšķiras no manējās. Ja Django joprojām darbojas 3.x versijā, varat turpināt bez problēmām.

Django projekta uzsākšana

Kad esat instalējis Django, ir pienācis laiks izveidot URL saīsinātāja vietnes struktūru. Vai atceries, kas ir Django projekts? Izveidosim to, izpildot šādu komandu.

django-admin startproject config

Izskaidrojot visu par šo komandu, django-admin ir komandrindas utilīta, kas veic visus nepieciešamos uzdevumus, lai izveidotu Django projektu. Daļa “Startproject” ir komanda, ko izpilda utilīta Django-admin, un config ir tā projekta nosaukums, kuru mēs izveidosim.

Ir svarīgi uzsvērt, ka konfigurācija var būt jebkurš nosaukums, kuru vēlaties. Iemesls, kāpēc es izmantoju config kā šī projekta nosaukumu, ir tikai ērtības dēļ. Ir patīkami pārslēgties starp projektiem un joprojām ir tāda pati nosaukumu piešķiršanas kārtība. Tāpēc nebaidieties izmantot citus projektu nosaukumus, kad vien vēlaties.

  Adobe InCopy: izmaksas, līdzekļi un lejupielāde

Kā jūs, iespējams, pamanījāt, tagad jums ir konfigurācija/mape, un tajā ir daudz failu. Vēlāk mēs redzēsim projekta failu struktūru. Pagaidām ievadīsim projekta direktoriju un palaidīsim vietējo serveri.

cd config/

Vissvarīgākais fails, ko izmantosit, ir skripts manage.py. Tam ir tāda pati funkcionalitāte kā django-admin, taču galvenā tā izmantošanas priekšrocība ir tā, ka, palaižot projektu, varat pārvaldīt iestatījumus.

Tagad redzēsim, vai viss darbojas pareizi.

python manage.py runserver

URL saīsinātāja lietotnes izveide

Ir pienācis laiks izveidot projekta galveno lietotni. Lai veiktu šo uzdevumu, jūs izmantosit failu manage.py.

python manage.py startapp urlshortener

Tādējādi tiek izveidota Django lietotne ar nosaukumu urlshortener. Ja palaižat koks komandu, jūs saņemsiet kaut ko līdzīgu šim.

.
├── 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

Noskaidrosim dažādus līdz šim izveidotos failus. “config” ir mūsu projekta nosaukums, un tas ir nosaukts tieši konvencijas dēļ. Konfigurācijas iekšpusē jūs saņemat settings.py, tas ir fails, kurā iestatāt visus sava projekta iestatījumus. urls.py ir vietrāžu URL vispārējā konfigurācija projektā. Tas nosaka visu projektā esošo lietojumprogrammu URL ceļus.

Neuztraucieties pārāk daudz par failiem asgi.py un wsgi.py. Šie ir faili, kas ļauj konfigurēt lietojumprogrammu izvietošanas laikā.

Manage.py ir python skripts, kas ļauj palaist visas pieejamās komandas Django-admin.

Apskatot urlshortener, kas ir tikko izveidotās lietotnes nosaukums, jūs varat pamanīt, ka tajā ir dīvaina mape ar nosaukumu “migrations/” un daži citi faili, kas ir būtiski jebkuras lietotnes loģikai.

apps.py ir vieta, kur atrodas lietotnes konfigurācija. Parasti jūs ar to nejaucāties, izņemot gadījumus, kad darāt diezgan progresīvas lietas.

admin.py ir vieta, kur jūs reģistrējat savus modeļus, lai tie būtu redzami Django administrēšanas panelī.

models.py ir vissvarīgākais. Šajā modulī ir jādefinē modeļi, kas (neskaidri sakot) ir veids, kā dati tiek glabāti. Vairāk par modeļiem uzzināsiet vēlāk.

migrations/ ir mape, kurā tiek glabātas Django migrācijas. Mēs to padziļināti apskatīsim vēlāk.

tests.py ir fails, kurā tiek glabāti testi. Šajā apmācībā mēs neapspriedīsim testēšanu.

views.py ir fails, kurā tiek glabāti skati. Būtībā tas nosaka, kā lietotājs mijiedarbosies ar visiem jūsu lietotnes aspektiem.

Django lietotnes instalēšana

Pirms turpināt, atveriet failu settings.py un modificējiet INSTALLED_APPS mainīgo, pievienojot lietotni 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',
]

Tas ir ikdienišķs process, kad veidojat lietotni. Tāpēc katru reizi, kad to darāt, neaizmirstiet to instalēt projekta iestatījumos.

MVT modeļa izpratne

Modelis, skats, veidne ir programmatūras dizaina modelis, ko Django izstrādātāji izmanto, lai izveidotu tīmekļa lietojumprogrammas.

Tas ir balstīts uz 3 galvenajiem jēdzieniem. Modelis (dati), Skats (Lietotāja mijiedarbība ar datiem), Veidne (Kā lietotāji redz datus).

Modeļi ir Python klases, kas nosaka visus laukus un to datu uzvedību, kurus vēlaties saglabāt. Parasti katrs modelis attiecas uz unikālu tabulu datubāzē

Skati to vienkāršākajā izteiksmē ir izsaucamie elementi, kas saņem pieprasījumu no lietotāja un ģenerē atbildi. Starp šo procesu notiek biznesa loģika. Es zinu, ka “biznesa loģika” ir diezgan neskaidrs jēdziens, tāpēc ļaujiet man paskaidrot, kas tas ir. Biznesa loģika ir veids, kā dati tiek izveidoti, uzglabāti un dzēsti, tas arī viss.

Visbeidzot, veidnes ir teksta dokumenti (parasti HTML), kas tiek rādīti lietotājiem. Tās mērķis ir sniegt datus pēc iespējas tīrāk. Django ir iekļauta mini valoda, ko sauc Django veidņu valoda (DTL) kas ļauj teksta dokumentos iekļaut daļu no python iespējām.

Izveidojiet Shortener modeli

Kad esat ātri sapratis MVT modeli, sāksim izveidot Django URL saīsinātāju no jauna.

Vispirms definēsim saīsinātāja modeli modelī.py failā.

'''
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}'

Es zinu. Tā ir diezgan liela klase, kurā notiek daudz dīvainu lietu, taču nevajag izmisumā. Es soli pa solim apskatīšu katru svarīgo lietu.

Modeļa skaidrojums

Pirmkārt, mēs importējam modeļu moduli. Šis modulis satur visu funkcionalitāti, kas mums nepieciešama, lai izveidotu Django modeli.

Aplūkojot modeli “Shortener”, vispirms jāatzīmē, ka tas paplašina modeļus. Modelis. Faktiski jebkuram modelim jebkurā Django lietotnē ir jābūt apakšklasei modeļi.Modelis klasē.

Pēc tam mēs definējam visus laukus, kas modelim būs datu bāzē. Lauks “izveidots” ir saīsinātās saites izveides datums un laiks, tāpēc mēs izmantojam DateTimeField, lai izveidotu šāda veida funkcionalitāti. Mēs izmantojam argumentu auto_now_add=True, jo mēs vēlamies, lai lauks tiktu mainīts tikai tad, kad tiek izveidota instance.

Otrais lauks times_followed attiecas uz saīsinātā URL izmantošanas reizēm. Tas ir PositiveIntegerField, un mēs norādām noklusējuma vērtību nulle. Tas nozīmē, ka katru reizi, kad gadījums ir izveidojis lauku times_followed, Django aizpildīs šo lauku ar 0.

No otras puses, long_url attiecas uz lietotāja ievadīto URL. Tas ir URL lauks, jo mēs vēlamies, lai lietotājs ievadītu tikai šādas formas rakstzīmes: http://yoursite.com.

Pēdējais lauks ir short_url, un tajā ir interesanta informācija. Mēs norādām, ka tas var būt tikai 15 rakstzīmes garš, tam jābūt unikālam, kas nozīmē, ka šajā laukā nedrīkst būt atkārtoti elementi. Visbeidzot, mēs norādām, ka to var atstāt tukšu, kas nozīmē, ka, strādājot ar veidlapām, lietotājiem nebūs jāraksta savs saīsinātais kods.

Meta iekšējā klase, pastāstiet mums, kā klasei ir jāuzvedas, un mēs uzstādām, ka saīsinātāju objektu secība (izsaucot Shortener.objects.all()) tiks diskriminēta pēc jaunākajiem objektiem.

Metode __str__ norāda, kā modelis ir jādrukā. Tātad, ja mums ir objekts ar long_url = “https://pcdream.lt.com/” un saīsinātu daļu “123456”, mēs to izdrukājam.

https://pcdream.lt.com/ to 123456

Tagad ir pienācis laiks meklēt veidu, kā nejaušā veidā saglabāt īso saiti.

  Kā Python izveidot skaitļu uzminēšanas spēli?

Saīsināšanas funkcionalitātes izveide

Mēs izveidosim 2 pielāgotas funkcijas. Pirmais ģenerēs nejaušu kodu, bet otrais neļaus iegūt atkārtotus nejaušus kodus no Shortener modeļa. Lai to izdarītu, lietotnē “urlshortener” izveidojiet failu utils.py.

touch utils.py

Šajā failā mēs izmantosim izvēles funkciju no nejauši iebūvētā moduļa. Tas atvieglo uzdevumu izvēlēties nejaušas rakstzīmes, lai izveidotu kodu.

'''
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)]
    )

Kā redzat, šī funkcija atgriež nejaušu virkni, kuras garums ir norādīts iestatījumu failā vai 7 pēc noklusējuma. Jūs izmantojat funkciju getattr, lai iegūtu mainīgo no iestatījumu moduļa, taču, ja mainīgais nav norādīts, netiek parādīta kļūda.

Veiksim matemātiku. Ja mums ir 7 vietas, kur katrā vietā var būt līdz 62 rakstzīmēm, iespējams permutācijas ir:

Tātad, pamatojoties uz šiem ātrajiem aprēķiniem, saīsināto daļu var aizpildīt līdz 2,5 triljoniem dažādu kodu. Tāpēc mēs varam aizmirst par izkļūšanu no nejauši saīsinātiem URL.

Lai gan var pastāvēt tik daudz permutāciju, pastāv neliela iespējamība iegūt atkārtotas saīsinātas daļas. Tā ir problēma, jo mēs iestatījām lauku shortened_url kā unikālu. Tāpēc šī funkcija ir tik noderīga.

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

Paskatīsimies, kas šeit notiek. Funkcija izmanto kā argumentu “Saīsinātāja” modeļa gadījumu. Pirmkārt, funkcija ģenerē nejaušu kodu, izmantojot create_random_code. Pēc tam tas iegūst modeļa klasi un pārbauda, ​​vai ir kāds cits objekts, kuram ir tāds pats short_url. Ja tas notiek, tas pats palaižas vēl vienu reizi, bet, ja viss ir kārtībā, tas atgriež random_code.

Vēlāk jūs mijiedarbosities ar čaulu, lai tuvāk apskatītu šo funkciju.

Pēc lietderības funkcijas izveidošanas izmantosim to, lai izveidotu nejaušus kodus saīsinātāja modelī.

Saglabāšanas metodes modificēšana

“Saīsinātāja” klases beigās jūs gatavojaties modificēt modeļa saglabāšanas metodi. Saglabāšanas metode tiek izsaukta katru reizi, kad objekts tiek saglabāts datu bāzē, tāpēc mēs redzēsim, kā to izmantot šeit.

# 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)

Saglabāšanas metode tiek pārrakstīta, kas nozīmē, ka jūs ieviešat jaunu funkcionalitāti jau esošai vecāku metodei. Būtībā tas norāda Django, ka katru reizi, kad tiek saglabāts objekts “Shortener” un nav norādīts short_url, tas ir jāaizpilda ar nejaušu kodu.

Notiek migrācijas

Tagad ir pienācis laiks veikt un palaist Shortener modeļa migrācijas. Lai to izdarītu, saknes projekta mapē palaidiet šādas komandas.

$ 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

Pagaidām jums nav jāuztraucas par to, kas ir migrācija. Vienkārši paturiet prātā, ka, palaižot šīs divas komandas, Django izveido a db.sqlite datu bāze failu, pamatojoties uz jūsu definētajiem modeļiem.

Izveidosim dažus objektus ar Django apvalku.

$ python manage.py shell

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

Gandrīz šādi darbosies visi saīsinātie objekti.

Rakstīšanas skati

Kā jau teicu iepriekš, skats ir vienkārša funkcija, kas pieņem pieprasījumu un atgriež atbildi. Tātad, redzēsim, kā izveidot labdienu pasaules uzskatu.

Pamata veidnes atbilde

Faila “urlshortener/views.py” iekšpusē izveidojiet funkciju 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")

Tas atgriež vienkāršu ziņojumu “Sveika pasaule”. Vēlāk jūs redzēsiet, kā tas izskatās pārlūkprogrammā. Tagad izveidojiet “urls.py”, tur būs visi lietotnes URL modeļi.

pieskarieties urls.py

Pievienojiet šādu kodu.

'''
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")
]

Mainīgais lietotnes nosaukums deklarē (kā norāda nosaukums) urlshortener lietotnes nosaukumiem.

Ātri paskaidrojot, ka mēs importējam ceļa funkcija, kas atgriež elementu, kas jāiekļauj lietotnes URL modeļos. Name atribūts ir ceļa nosaukumtelpa, kuru vajadzības gadījumā var izsaukt veidnēs.

Tagad pārveidosim kopējos projekta URL.

# 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'))
]

Tagad atkal palaidīsim serveri.

python manage.py runserver

Ja palaižat serveri, jūs saņemsit vienkāršu ziņojumu “Sveika pasaule”. Tas ir tāpēc, ka jūs iekļaujat URL rakstus no URL saīsinātāja lietotnes kopējā projektā.

Tas ir tikai sākuma punkts. Tagad ir pienācis laiks izveidot veidlapu, lai ļautu lietotājam pašam izveidot saīsinātos URL.

Veidlapu veidošana

In Django, a formā ir vienkārša klase, kas ļauj iegūt ievadi no Lietotāja.

Jūs gatavojaties izveidot failu forms.py. Šajā failā ir ierasts saglabāt visas lietotnes formas.

cd urlshortener/
touch forms.py

Šī faila iekšpusē jūs izveidosit klasi “ShortenerForm”, kas stiepjas no “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',)

Tā ir modeļa forma, jo tās mērķis ir izveidot modeļa objektu no lietotāja ievades. Mēs izmantojam arī logrīka argumentu, kas ļauj norādīt atribūtu “class” (klase CSS, nevis python). Tas ir tāpēc, ka mēs vēlāk stilizēsim lietotni, izmantojot sāknēšanas programmu.

Skatu pabeigšana

Pēc veidlapu izveides ir laiks izveidot lietojumprogrammas galīgo biznesa loģiku.

Saīsinātāja lietotnē pārejiet uz failu views.py un modificējiet skatu home_view. Jūs varat pārbaudīt Github repo šajā brīdī, lai gūtu priekšstatu par to, kā izskatās projekta struktūra.

URL saīsinātāja lietotnei ir divi skati:

  • Sākuma skats: tiek parādīta saīsinātā veidlapa un jaunais URL, ja veidlapa jau ir iesniegta.
  • Novirzīšanas skats: tiek novirzīts uz garo URL un sekotajam laikam tiek pievienots 1.
  • Sāksim ar mājas skatu, kas ir vissarežģītākais. Jums būs jāimportē Shortener modelis un veidlapa. Jūs joprojām izmantojat funkciju, jo es vēlos, lai jūs saprastu visu skata datu plūsmu. Jūs arī izmantosit ceļu veidnei (kas vēl nav izveidota).

      Labot neizdevās inicializēt BattlEye pakalpojuma vispārīgo kļūdu

    Mājas skats

    '''
    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)
    

    Skats ir balstīts uz diviem nosacījumiem:

  • Ja HTTP metode ir vienāda ar GET: kā kontekstu mēs nododam tikai saīsinātāja veidlapu, ko izmanto, lai izveidotu Shortener objektus.
  • Ja HTTP metode ir vienāda ar POST: mēs joprojām nododam veidlapu kontekstā, jo vēlamies, lai lietotājs varētu ievadīt citu URL. Taču mēs nosūtām izlikšanas pieprasījumu uz citu veidlapu, kuras nosaukums ir used_form.
  • Sarežģīts veids, kā dinamiski iegūt visu vietnes URL, ir izmantot pieprasījuma objekta metodi build_absolute_uri.

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

    Kā drošs veids, kā apstrādāt nepareizu pieprasījumu (lietotājs nav ievadījis derīgu URL), mēs saņemam veidlapas kļūdas, nododam tās kā kontekstu un atveidojam veidni kā parasti. Vēlāk redzēsit, kā veidnē ieviest kļūdu parādīšanu.

    Pārvirzīt skatu

    Redirect_url_view ir nedaudz vienkāršāks. Tas ir detalizēts skats, kas nozīmē, ka skats darbojas tikai ar objektu.

    Šī funkcija izmanto kā parametrus, lietotāja pieprasījumu un URL saīsināto_daļu. Nav nepieciešams norādīt, kāda veida pieprasījums tiek saņemts, jo šajā skatā mēs nestrādājam ar veidlapām.

    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 :(')

    Mēs aizsargājam skatu ar try/except paziņojumu, ja saīsinātā daļa netiek atrasta datu bāzē. Ja objekts tiek atrasts, tas laukam times_followed pievieno 1 un ar funkciju HttpResponseRedirect novirza uz vietnes URL, kas atbilst nejaušajam kodam.

    URL atjaunināšana

    Kad esat izveidojis divus lietotnes skatus, ir pienācis laiks izveidot gala URL modeļus, iekļaujot ceļu uz redirect_url_view.

    Kā vienmēr, jūs sākat, importējot skatus un pēc tam izveidojot ceļa funkciju un nododot kā argumentus:

    • URL maršruts
    • Skats, kas norāda uz taku
    • Ceļa nosaukums
    '''
    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"),
    ]
    

    Izmantojot šo URL iestatījumu, lietotnes maršrutēšana izskatās šādi.

    • localhost:8000/: Sākuma skats
    • localhost:8000/URL-kods: novirzīšana uz garo URL

    Veidņu veidošana

    Jūs esat gandrīz klāt. Vienīgais, kas jūs atšķir no šīs lietotnes izveides, ir lietotāja interfeiss. Šim nolūkam mēs izmantojam Django veidnes.

    Veidnes tiek izmantotas, lai lietotnes lietotājam nodrošinātu tīru saskarni. Šie faili tiek izveidoti lietotnes iekšpusē dubultā mapju struktūrā šādā formā: “veidnes/lietotnes nosaukums”

    # urlshortener directory
    mkdir -p templates/urlshortener/

    Piezīme. Dubultās mapes struktūra un Django Template valoda ir ārpus šīs apmācības darbības jomas, taču par tām varat lasīt oficiālā dokumentācija.

    Pamata veidne

    Django pieļauj veidņu pārmantošanu. Tas nozīmē, ka mēs varam izveidot bāzes veidni un paplašināt to ar mērķi ievērot DRY (Neatkārtojies) principu.

    cd templates/urlshortener
    touch base.html

    Fails base.html ir pieņemts, un tas nozīmē, ka katrai citai lietotnes veidnei ir jābūt šīs veidnes paplašinājumam.

    <!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>
    

    Mēs izmantosim sāknēšanas CDN, lai izveidotu ātru un skaistu interfeisu, neizmantojot CSS vai javascript failus.

    Ja vēlaties padziļināti uzzināt par DTL tagiem, varat to izdarīt, izmantojot oficiālie dokumenti.

    Mājas veidne

    Sākuma veidne, kas iegūta no faila base.html. Tas nozīmē, ka šajā veidnē ir iekļauts viss HTML no vecākfaila.

    {% 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 %}

    Es ātri izskaidrošu šīs veidnes datu plūsmu:

    • Tiek parādīta saīsinātāja forma. Iekšpusē, crsf marķieris ir iestatīts (drošības apsvērumi), un tiek rādīts tikai veidlapas garais URL lauks. Atcerieties, ka šajā laukā ir CSS klase “form-control form-control-lg”, jo mēs to iestatījām formā.
    • Ja tiek atrastas kļūdas, parādiet tās
    • Ja POST darbība izdodas, tiek parādīts jaunais URL.

    Galīgais pieteikums

    Apsveicam! 🎉. Jūs esat izveidojis pilnīgu funkcionālu URL saīsināšanas lietotni ar Django.

    Šeit ir daži ekrānuzņēmumi, kas parāda, kā lietojumprogramma izskatās.

    Iegūstiet tikai:

    Saīsinot URL, radās kļūda:

    Veiksmīgi saīsināts URL:

    URL novirzīts:

    Ko jūs domājat par šīs URL saīsināšanas lietotnes demonstrācijas atklāšanu kādam? Pārbaudiet, kā Django Demo lietotni atklāt internetā.

    Izaicinājums 🔥

    Ja jūtaties ērti ar savām Django prasmēm, kāpēc gan nepraktizēt ar izaicinājumu?.

    Klonējiet šīs lietojumprogrammas kodu un izveidojiet autentifikācijas sistēmu, kurā tikai reģistrētie lietotāji var saīsināt savus URL.

    Kad esat pabeidzis, nosūtiet izvilkšanas pieprasījumu un piezvaniet man Twitter lai parādītu savus sasniegumus.

    Iesaiņošana

    Jūs esat sasniedzis šīs apmācības beigas. Ticiet vai nē, jūs tikko pārskatījāt visus galvenos Django projekta izveides aspektus. Es ceru, ka jums tas šķita ārkārtīgi noderīgs.

    Šajā apmācībā jūs:

    • Uzziniet par Django lietotnes izveides darbplūsmu.
    • Izveidoja CV projektu
    • Izprata Django projektu un Django lietotņu atšķirības un struktūru.
    • Atklāja MVT modeli.
    • Izveidoti funkciju bāzes skati
    • Lai izveidotu vienkāršus modeļus, tika izmantots Django ORM (Object Relational Mapper).

    Tas arī viss, ar to ir daudz ko aptvert Django tīmekļa ietvarstāpēc sazinieties, lai iegūtu vairāk pārsteidzošu pamācību.