Una guida per creare un'app per accorciare URL con Django

Il modo migliore per imparare Django, o qualsiasi abilità, è applicare le conoscenze che hai creando progetti funzionali.

Django è il framework di sviluppo web Python più utilizzato. Le sue funzionalità integrate e l'ampia quantità di pacchetti di terze parti lo hanno reso uno dei framework web più amati in tutto il mondo.

È veloce, affidabile e ha molte funzionalità integrate. Ad esempio, un sistema di autenticazione del foro, che ti consente di concentrarti sulle funzionalità principali della tua app. Inoltre, puoi installare pacchetti esterni per eseguire attività ancora più complesse, come Django-allauth , che ti consente di registrare gli utenti con i loro account social.

Ma esponiamo alcuni fatti. Django è un framework così grande che a volte è difficile iniziare con esso.

Quindi oggi costruirai da zero un'applicazione Django totalmente funzionale.

Alla fine di questo tutorial, dovrai:

• Ho scritto un'app per accorciare gli URL
• Comprendi il modello Django MVT
• Hai imparato il flusso di lavoro della creazione di un progetto

Prerequisiti

Tutti i seguenti requisiti sono facoltativi e ti aiuteranno a seguire il tutorial. Ma se non hai esperienza con nessuno di questi, non preoccuparti. Il passo più importante è il primo.

• Comprensione di base dei comandi UNIX (ls, cd, rm, touch)
• Comprensione di base delle classi e delle funzioni Python
• Python installato sul tuo computer (forse ovvio ma dovevo includerlo)
• Sarebbe fantastico se avessi già costruito qualcosa con Django

Tutto il codice funzionante sarà disponibile su questo repository Github.

Ora che hai chiarissimo i concetti precedenti, entriamo nel merito.

Dichiarazione del progetto

In questo tutorial, creerai un accorciatore di URL. Fondamentalmente, un accorciatore di URL è un servizio che richiede un URL lungo e lo trasforma in uno compatto.

Ad esempio, se desideri condividere un tweet e includere un link al tuo sito web, ma stai affrontando il limite di caratteri, potresti utilizzare un accorciatore di URL.

Vediamolo con un grafico.

Come puoi vedere, l'abbreviatore di URL ottiene un URL lungo e ne restituisce uno corto. Questo è esattamente ciò che costruirai oggi.

Con questo progetto, ti eserciterai nell'utilizzo del modello MVT, imparerai le basi della progettazione di database con i modelli Django e imparerai come mostrare le informazioni all'utente tramite viste, URL e modelli.

Struttura di un progetto Django

Fondamentalmente, un sito Web Django è costruito su un singolo progetto e più app separate. Ognuna di queste app ha funzionalità specifiche ed è in grado di funzionare da sola.

Immaginiamo un'applicazione web complessa come Stackoverflow. La sua funzionalità si basa su due aspetti principali.

• Gestione utenti: accesso , disconnessione, reputazione, permessi
• Forum: domande, risposte, tag, filtri

Quindi, seguendo la struttura del sito Web Django, il progetto sarebbe chiamato StackOverflow che ha due app principali. L'app degli utenti e l'app del forum .

Ognuna di queste app ha funzionalità autonome. Ciò significa che entrambi contengono tutto il codice di cui hanno bisogno per funzionare correttamente.

Ciò include modelli (struttura del database), visualizzazioni (richieste e risposte), modelli URL specifici e, naturalmente, modelli e file statici (immagini, CSS, JavaScript). Ciò significa che qualsiasi app Django potrebbe essere riutilizzata poiché sono in grado di funzionare da soli.

Abbreviando, un progetto si riferisce a un insieme di configurazioni e app che ha lo scopo di creare un'applicazione Web. D'altra parte, un'app Django è una parte di un progetto, che è autonomo (ha tutto ciò di cui ha bisogno per funzionare) e il suo scopo è eseguire un'operazione specifica.

Imposta un progetto Django

In questa sezione, imposterai un progetto Django. A tal fine, utilizzerai diversi strumenti come un ambiente virtuale per organizzare le dipendenze Python e gli script Django più importanti. Django-admin e manage.py

Ambiente virtuale

Consiglio sempre di lavorare con ambienti virtuali durante la creazione di app con Django. È il modo più efficiente per mantenere un insieme specifico di dipendenze. Ma il suo scopo principale è isolare i pacchetti di sviluppo da quelli globali.

Quindi creiamo un ambiente virtuale con python il comando form integrato.

Nota: questo metodo richiede Python 3.6 o versioni successive per funzionare.

 python -m venv .venv

Questo comando utilizza il comando python -m o python –mod . Fondamentalmente esegue un modulo o una libreria, come script. Secondo il significato di questo comando, venv è la libreria che stiamo eseguendo e .venv si riferisce al nome dell'ambiente virtuale che vogliamo creare.

Quindi, in un linguaggio semplice, questo comando significa.

Ehi Python, esegui come script la libreria integrata venv e crea un nome virtualenv .venv

Ora è il momento di attivare l'ambiente virtuale che abbiamo appena creato, con il seguente comando.

 source .venv/bin/activate

Per affermare di non avere pacchetti installati nel nuovo venv, esegui.

 pip freeze

Se hai attivato correttamente l'ambiente virtuale, non otterrai alcun output. Questo perché non abbiamo ancora installato nulla.

Entriamo in Django

Per creare la nostra applicazione per accorciare gli URL, inizieremo installando il pacchetto Django. Django è un pacchetto di terze parti, quindi dobbiamo installarlo con 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

Nota: ricorda che $ non è altro che il tuo simbolo di shell.

Per verificare se l'installazione è andata a buon fine, controlliamo nuovamente i pacchetti installati della nostra venv.

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

Non preoccuparti se le versioni che ottieni sono diverse dalla mia. Se Django è ancora sulla versione 3.x puoi continuare senza problemi.

Avvio di un progetto Django

Una volta installato Django, è il momento di creare la struttura del sito Web URL shortener. Ricordi cos'è un progetto Django? Creiamone uno eseguendo il comando seguente.

 django-admin startproject config

Spiegando tutto su questo comando, django-admin è un'utilità della riga di comando che esegue tutte le attività necessarie per creare un progetto Django. La parte "startproject" è il comando eseguito dall'utility Django-admin e config è il nome del progetto che andremo a creare.

È importante sottolineare che config può essere qualsiasi nome tu voglia. Il motivo per cui uso config come nome di questo progetto è solo per comodità. È bello passare da un progetto all'altro e avere ancora la stessa convenzione di denominazione. Quindi non aver paura di usare altri nomi di progetto ogni volta che vuoi.

Come puoi notare ora hai una cartella config/ e al suo interno ci sono molti file. Più avanti vedremo la struttura dei file del progetto. Per ora, entriamo nella directory del progetto ed eseguiamo il server locale.

 cd config/

Il file più importante che utilizzerai è lo script manage.py . Ha le stesse funzionalità di django-admin , ma il vantaggio principale dell'utilizzo è che ti consente di gestire le impostazioni durante l'esecuzione del progetto.

Ora vediamo se tutto funziona correttamente.

 python manage.py runserver

Creazione dell'app per l'accorciamento degli URL

È il momento di creare l'app principale del progetto. Utilizzerai il file manage.py per eseguire questa operazione.

 python manage.py startapp urlshortener

Questo crea un'app Django, con il nome urlshortener . Se esegui il comando tree, otterrai qualcosa del genere.

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

Facciamo chiarezza sui diversi file creati fino a questo momento. "config" è il nome del nostro progetto ed è chiamato così solo per la convenzione. All'interno di config, ottieni settings.py , è il file in cui imposti tutte le impostazioni del tuo progetto. urls.py è la configurazione complessiva degli URL all'interno del progetto. Definisce i percorsi URL di tutte le applicazioni all'interno del progetto.

Non preoccuparti troppo dei file asgi.py e wsgi.py Questi sono file che ti consentono di configurare la tua applicazione nella distribuzione.

Il manage.py è lo script python che ti permette di eseguire tutti i comandi disponibili di Django-admin.

Dando un'occhiata all'interno di urlshortener che è il nome dell'app che hai appena creato, potresti notare che c'è una strana cartella chiamata "migrations/" e alcuni altri file che sono cruciali per la logica di qualsiasi app.

apps.py è dove risiede la configurazione dell'app. Di solito non ci si scherza, tranne per il fatto che si stanno facendo cose piuttosto avanzate.

admin.py è dove registri i tuoi modelli per renderli visibili all'interno del pannello di amministrazione di Django.

models.py è il più importante. All'interno di questo modulo, è necessario definire i modelli, che (vagamente dicendo) sono il modo in cui i dati vengono archiviati. Sentirai di più sui modelli in seguito.

migrations/ è la cartella in cui sono archiviate le migrazioni di Django. Daremo uno sguardo approfondito più avanti.

tests.py è il file in cui sono archiviati i test. Non tratteremo i test in questo tutorial.

views.py è il file che memorizza le visualizzazioni. Fondamentalmente, definisce come l'utente interagirà con tutti gli aspetti della tua app.

Installazione di un'app Django

Prima di continuare, aprire il settings.py di file e modificare INSTALLED_APPS variabile aggiungendo l'applicazione 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', ]

Questo è un processo di routine quando crei un'app. Quindi ogni volta che lo fai, non dimenticare di installarlo nelle impostazioni del progetto.

Comprendere il modello MVT

Il modello Model, View, Template è il modello di progettazione del software utilizzato dagli sviluppatori Django per creare applicazioni web.

Si basa su 3 concetti principali. Modello (dati), Visualizza (Interazione dell'utente con i dati), Modello (Come gli utenti vedono i dati).

I modelli sono classi Python, che definiscono tutti i campi e il comportamento dei dati che si desidera memorizzare. Normalmente ogni modello fa riferimento a una tabella univoca nel database

Le viste, nella loro espressione più semplice, sono callable che accettano una richiesta dall'utente e generano una risposta. Tra quel processo si verifica la logica aziendale. So che la "logica aziendale" è un concetto piuttosto oscuro, quindi lascia che ti spieghi esattamente di cosa si tratta. La logica aziendale è il modo in cui i dati vengono creati, archiviati ed eliminati, tutto qui.

Infine, i modelli sono documenti di testo (solitamente Html) che vengono mostrati agli utenti. Il suo scopo è presentare i dati nel modo più pulito possibile. Django incorpora un mini-linguaggio chiamato Django template language (DTL) che ti consente di incorporare parte della potenza di Python nei documenti di testo.

Crea il modello Shortener

Una volta acquisita una rapida comprensione del pattern MVT, iniziamo a creare da zero l'abbreviatore di URL Django.

Prima di tutto, definiamo il modello di accorciatore all'interno del file 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}'

Lo so. È una classe piuttosto vasta, con un sacco di cose strane in corso, ma non disperare. Andrò passo dopo passo su ogni cosa importante.

Spiegazione del modello

Prima di tutto, importiamo il modulo models . Questo modulo contiene tutte le funzionalità necessarie per creare un modello Django.

Dando un'occhiata al modello “Shortener”, la prima cosa da notare è che estende i models.Model . In effetti, qualsiasi modello in qualsiasi app Django deve essere una sottoclasse della classe models.Model.

Quindi definiamo tutti i campi che il modello avrà nel database. Il campo "creato" è la data e l'ora in cui viene creato il collegamento abbreviato, quindi utilizziamo DateTimeField per creare questo tipo di funzionalità. Usiamo l'argomento auto_now_add=True perché vogliamo che il campo venga modificato solo quando viene creata l'istanza.

Il secondo campo times_followed riferisce alle volte in cui è stato utilizzato l'URL abbreviato. È un PositiveIntegerField e specifichiamo un valore predefinito pari a zero. Ciò significa che ogni volta che un'istanza ha creato il campo times_followed , Django compilerà quel campo con 0.

D'altra parte, long_url riferisce all'URL long_url dall'utente. È un URLField , perché vogliamo che l'utente inserisca solo i caratteri del modulo: http://yoursite.com .

L'ultimo campo è short_url e contiene dettagli interessanti. Specifichiamo che può essere lungo solo 15 caratteri, deve essere univoco, il che significa che in quel campo non possono essere ripetuti elementi. Infine, indichiamo che può essere lasciato vuoto, il che significa che quando si lavora con i moduli gli utenti non dovranno scrivere il proprio codice abbreviato.

La classe interna Meta, ci dice come deve comportarsi la classe, e impostiamo che l'ordinamento (chiamando Shortener.objects.all() ) degli oggetti shortener sarà discriminato da quelli più recenti.

Il metodo __str__ indica come deve essere stampato il modello. Quindi, se abbiamo un oggetto con long_url = "https://geekflare.com/" e la parte abbreviata "123456", lo stampiamo.

 https://geekflare.com/ to 123456

Ora è il momento di cercare un modo per salvare il collegamento breve in modo casuale.

Creazione di funzionalità di accorciamento

Creeremo 2 funzioni personalizzate. Il primo genererà un codice casuale e il secondo impedirà di ottenere codici casuali ripetuti dal modello Shortener. Per fare ciò, crea un file utils.py all'interno dell'app "urlshortener".

 touch utils.py

All'interno di questo file, utilizzeremo la funzione di scelta dal modulo integrato casuale. Ciò facilita il compito di scegliere caratteri casuali per creare il codice.

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

Come puoi vedere, questa funzione restituisce una stringa casuale della lunghezza specificata nel file delle impostazioni o 7 per impostazione predefinita. Stai usando la funzione getattr per ottenere una variabile dal modulo delle impostazioni, ma senza generare un errore se la variabile non è specificata.

Facciamo un po' di matematica. Se abbiamo 7 posti dove possono esserci fino a 62 caratteri disponibili per ogni posto, le possibili permutazioni sono:

Quindi, sulla base di questi rapidi calcoli, la parte abbreviata può essere compilata fino a 2,5 trilioni di codici diversi. Quindi possiamo dimenticare di uscire da URL abbreviati casuali.

Sebbene possano esistere così tante permutazioni, c'è una piccola probabilità di ottenere parti accorciate ripetute. Questo è un problema poiché abbiamo impostato il campo shortened_url in modo che sia univoco. Ecco perché la seguente funzione è così utile.

 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

Vediamo cosa sta succedendo qui. La funzione prende come argomento un'istanza del modello "Shortener". Innanzitutto, la funzione genera un codice casuale utilizzando create_random_code . Quindi ottiene la classe del modello e controlla se c'è qualche altro oggetto che ha lo stesso short_url . Se lo fa si esegue ancora una volta, ma se tutto va bene restituisce il random_code.

Successivamente interagirai con la shell, per dare un'occhiata da vicino a questa funzione.

Dopo aver creato la funzione di utilità, usiamola per creare codici casuali nel modello di accorciamento.

Modifica del metodo di salvataggio

Alla fine della classe "Shortener", modificherai il metodo di salvataggio del modello. Il metodo save viene chiamato ogni volta che un oggetto viene salvato nel database, quindi vedremo come usarlo qui.

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

Il metodo di salvataggio viene sovrascritto, il che significa che stai introducendo nuove funzionalità a un metodo genitore preesistente. Fondamentalmente sta dicendo a Django che ogni volta che un oggetto "Shortener" viene salvato e lo short_url non è specificato, deve essere riempito con un codice casuale.

Migrazioni in corso

Ora è il momento di eseguire ed eseguire le migrazioni del modello Shortener. Per farlo, esegui i seguenti comandi nella cartella principale del progetto.

 $ 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

Per ora, non devi preoccuparti di cosa sono le migrazioni. Tieni presente che durante l'esecuzione di questi due comandi Django crea un file di database db.sqlite, in base ai modelli che hai definito.

Creiamo alcuni oggetti con la shell Django.

 $ python manage.py shell >>> from urlshortener.models import Shortener >>> s = Shortener(long_url="https://geekflare.com") >>> s.short_url '' >>> s.save() >>> s.short_url 'kdWFVIc' >>> s.long_url 'https://geekflare.com' >>> print(s) https://geekflare.com to kdWFVIc

Questo è più o meno come funzioneranno tutti gli oggetti accorciatori.

Scrivere viste

Come ho detto prima, una vista è una semplice funzione che accetta una richiesta e restituisce una risposta. Quindi vediamo come creare una visione del mondo Hello.

Modello di risposta di base

All'interno del file "urlshortener/views.py" crea una funzione 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")

Restituisce un semplice messaggio “Hello world”. In seguito vedrai come appare nel browser. Ora crea un "urls.py", ci saranno tutti i pattern URL dell'app.

touch urls.py


Aggiungi il seguente codice.

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

La variabile appname dichiara (come suggerisce il nome) lo spazio dei nomi dell'app urlshortener.

Spiegando rapidamente stiamo importando la funzione path, che restituisce un elemento da includere negli urlpattern dell'app. L'attributo name è lo spazio dei nomi del percorso, che può essere chiamato all'interno dei template se necessario.

Ora modifichiamo gli URL complessivi del progetto.

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

Ora eseguiamo di nuovo il server.

 python manage.py runserver

Se esegui il server, riceverai un semplice messaggio "Hello world". Questo perché stai includendo gli urlpattern dall'app URL shortener nel progetto complessivo.

Questo è solo un punto di partenza. Ora è il momento di creare un modulo per consentire all'utente di creare autonomamente URL abbreviati.

Creazione di moduli

In Django, un form è una semplice classe che consente di ottenere input dall'utente.

Stai per creare un file Forms.py. È una convenzione memorizzare tutte le forme dell'app in quel file.

 cd urlshortener/ touch forms.py

All'interno di quel file creerai una classe "ShortenerForm" che si estende da "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',)

È un modulo modello poiché il suo scopo è creare un oggetto modello dall'input dell'utente. Utilizziamo anche l'argomento widget, che ci consente di specificare l'attributo "class" (classe in CSS, non python). Questo perché in seguito stilizzeremo l'app con bootstrap.

Finire le viste

Dopo aver costruito i moduli è il momento di creare la logica di business finale dell'applicazione.

Passa al file views.py all'interno dell'app home_view e modifica la vista home_view . Puoi controllare il repository Github in questo momento per avere un'idea di come appare la struttura del progetto.

Sono disponibili due visualizzazioni per l'app URL shortener:

1. Vista Home: mostra il modulo abbreviato e il nuovo URL se il modulo è già stato inviato.
2. Reindirizza vista: reindirizza all'URL lungo e aggiunge 1 ai tempi seguiti.

Iniziamo con la vista home che è la più complessa. Sarà necessario importare il modello e il modulo di Shortener. Stai ancora utilizzando una funzione poiché voglio che tu capisca tutto il flusso di dati della vista. Inoltre, utilizzerai il percorso per un modello (che non è ancora stato creato).

vista casa

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

La vista si basa su due condizionali:

1. Quando il metodo HTTP è uguale a GET: passiamo solo come contesto, il modulo Shortener utilizzato per creare oggetti Shortener.
2. Quando il metodo HTTP è uguale a POST: Passiamo ancora il modulo nel contesto poiché vogliamo che l'utente possa inserire un altro URL. Ma stiamo passando la richiesta di posta a un altro modulo chiamato form_usato.

Un modo complicato per ottenere dinamicamente l'URL completo del sito consiste nell'usare il metodo dell'oggetto di richiesta build_absolute_uri .

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

Come modo sicuro per elaborare una richiesta errata (l'utente non ha inserito un URL valido), otteniamo gli errori del modulo, li passiamo come contesto e rendiamo il modello come di consueto. In seguito vedrai come implementare la visualizzazione degli errori nel modello.

Reindirizza vista

Il redirect_url_view è un po' più semplice. È una vista dettagliata, il che significa che la vista funziona solo con un oggetto.

Questa funzione accetta come parametri la richiesta dell'utente e la shortened_part dell'URL. Non è necessario affermare il tipo di richiesta che stiamo ricevendo, poiché non stiamo lavorando con i moduli in questa vista.

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

Proteggiamo la vista con un'istruzione try/eccetto , nel caso in cui la parte abbreviata non venga trovata nel database. Se l'oggetto viene trovato aggiunge 1 al campo times_followed e reindirizza con la funzione HttpResponseRedirect all'URL del sito corrispondente al codice casuale.

Aggiornamento degli URL

Dopo aver creato le due visualizzazioni dell'app, è il momento di creare i pattern URL finali includendo il percorso per redirect_url_view .

Come sempre inizi importando le viste, quindi creando una funzione di percorso e passando come argomenti:

• Il percorso URL
• La vista che indica il sentiero
• Il nome del percorso

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

Con questa configurazione dell'URL, il routing dell'app è simile a questo.

• localhost:8000/ : Vista Home
• localhost:8000/URL-code : Reindirizzamento all'URL lungo

Creazione di modelli

Ci sei quasi. L'unica cosa che ti separa dall'aver creato questa app è l'interfaccia utente. Per questo, utilizziamo i modelli Django.

I modelli vengono utilizzati per eseguire il rendering di un'interfaccia pulita per l'utente dell'app. Questi file vengono creati all'interno dell'app in una struttura a doppia cartella della forma: “templates/appname”

 # urlshortener directory mkdir -p templates/urlshortener/

Nota: la struttura a doppia cartella e il linguaggio del modello Django vanno oltre lo scopo di questo tutorial, ma puoi leggerli nella documentazione ufficiale.

Modello base

Django consente l'ereditarietà dei modelli. Ciò significa che possiamo avere un modello di base ed estenderlo con lo scopo di seguire il principio DRY (Non ripetere te stesso).

 cd templates/urlshortener touch base.html

Il file base.html è una convenzione e significa che ogni altro modello nell'app deve essere un'estensione di questo.

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

Utilizzeremo il CDN di bootstrap, per creare un'interfaccia rapida e carina senza bisogno di file CSS o javascript.

Se vuoi conoscere a fondo i tag DTL, puoi farlo con i documenti ufficiali.

Modello di casa

Il modello home, inerente al file base.html. Ciò significa che questo modello include tutto l'HTML del file padre.

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

Spiegherò rapidamente il flusso di dati di questo modello:

• Viene visualizzato il modulo Accorciatore. All'interno è impostato il token crsf (Motivi di sicurezza) e viene mostrato solo il campo URL lungo del modulo. Ricorda che questo campo ha la classe CSS, "form-control form-control-lg", perché l'abbiamo impostata nel form.
• Se vengono trovati errori, mostrali
• Se l'operazione POST ha esito positivo, viene mostrato il nuovo URL.

Applicazione finale

Congratulazioni! . Hai creato un'app di abbreviazione URL funzionale completa con Django.

Ecco alcuni screenshot di come appare l'applicazione.

Ottieni solo:

Errore durante l'abbreviazione dell'URL:

URL abbreviato riuscito:

URL reindirizzato:

Cosa ne pensi di esporre una demo di questa app per accorciare gli URL a qualcuno? Controlla come esporre un'app Django Demo su Internet.

Sfida

Se ti senti a tuo agio con le tue abilità di Django, perché non esercitarti con una sfida?.

Clona il codice di questa applicazione e crea un sistema di autenticazione, dove solo gli utenti registrati possono abbreviare i propri URL.

Quando hai finito, invia una richiesta pull e inviami un ping su Twitter per mostrare i tuoi risultati.

Avvolgendo

Sei arrivato alla fine di questo tutorial. Che tu ci creda o no, hai appena rivisto tutti gli aspetti principali della creazione di un progetto Django. Spero che tu l'abbia trovato estremamente utile.

In questo tutorial:

• Imparato il flusso di lavoro della creazione di un'app Django.
• Costruito un progetto di curriculum
• Ha compreso le differenze e la struttura dei progetti Django e delle app Django.
• Scoperto il modello MVT.
• Viste di base della funzione creata
• Utilizzato Django ORM (Object Relational Mapper) per creare modelli semplici

Questo è tutto, c'è molto da fare con il framework web Django, quindi tieniti in contatto per tutorial più sorprendenti.