Pff ... schon wieder Datenbanken?
In einer relationalen Datenbank gibt es drei Hauptbeziehungen:
- Eins-zu-eins-Beziehung;
- Eins-zu-viele-Beziehung;
- Viele-zu-viele-Beziehung.
In diesem Artikel werden wir uns mit der ersten dieser Beziehungen befassen, der Eins-zu-Eins-Beziehung.
Normalerweise hat Django bereits ein Benutzermodell, das mit dem Framework geliefert wird. Es kommt mit eigenen Feldern, Methoden, Attributen usw. Der Nachteil dieses Benutzermodells ist, dass Sie keine benutzerdefinierten Felder hinzufügen können, abgesehen von den bereits in Django bereitgestellten Standardeinstellungen. Dies kann ein ernstes Problem sein, da ein Entwickler möglicherweise ein Benutzer- / Client-Profil aus einer Gruppe authentifizierter Benutzer vollständig konfigurieren muss. Beispielsweise benötigt eine Blog-Site möglicherweise ein Autorenprofil, das das Foto, die Kontaktadresse, das Hobby, die Nische usw. eines Benutzers enthält. Und das mit Django gelieferte Benutzermodell lässt dies nicht zu.
Um dieses Problem zu lösen, erstellen die Entwickler ein benutzerdefiniertes Profilmodell und verbinden es über eine Eins-zu-Eins-Beziehung mit dem Standardbenutzermodell in Django. Es kommt also vor, dass der Benutzer garantiert mit einem Profil verbunden ist und umgekehrt. Darüber hinaus ermöglicht diese Mechanik eine bessere Kontrolle über die Anpassung des Profilmodells.
Jetzt werde ich Ihnen zeigen, wie Sie dies in Django tun können.
1. Verwenden Sie das Standard-Django-Benutzermodell.
Erstellen Sie in der Anwendung, in der Sie das Profil erstellen möchten, eine neue forms.py- Datei . Importieren Sie in forms.py die folgenden Module:
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import UserErstellen Sie eine Klasse, von der geerbt werden soll
UserCreationForm. Erstellen Sie in dieser Klasse eine weitere Meta-Klasse mit zwei Variablen: modelund fields. Die Variable enthält modelIhr Benutzermodell und die Variable enthält die fieldsFormularfelder, die erstellt werden.
class createUserForm(UserCreationForm):
class meta:
model = User
fields = ['username', 'password1', 'password2']Mit dem obigen Code wird ein Formular mit Feldern für Benutzername, Passwort und Passwortbestätigung erstellt.
2. Erstellen Sie Ihr benutzerdefiniertes Benutzerprofilmodell. Importieren
Sie in Ihre Datei models.py das Standardbenutzermodell.
from django.contrib.auth.models import UserAls Nächstes müssen Sie Ihr eigenes Profilmodell erstellen und ein Benutzerfeld mit einer Eins-zu-Eins-Beziehung zum Standardbenutzermodell in Django erstellen.
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE, null=True,)
name = models.CharField(max_length=200, null=True)
email = models.CharField(max_length=200, null=True)
address = models.CharField(max_length=200, null=True)
def __str__(self):
return self.name3. Erstellen Sie eine Form für Ihr Profilmodell.
Öffnen Sie die Datei form.py und importieren Sie Ihr Profilmodell aus models.py. Fügen Sie außerdem einige andere Importe hinzu, die beim Erstellen Ihres Profilformulars hilfreich sind.
from django import forms
from django.utils.translation import ugettext_lazy as _
from .models import ProfileErstellen Sie dann eine Klasse, von der geerbt wird
forms.ModelForm. Erstellen Sie in dieser Klasse eine weitere Metaklasse mit zwei Variablen: modelund fields. Die Variable modelenthält das Profilmodell und fieldsdie Formularfelder, die erstellt werden.
class profileForm(forms.ModelForm):
class Meta:
model = Profile
fields = ['name', 'email', 'address']
#The labels attribute is optional. It is used to define the labels of the form fields created
labels = {
"name": _("Name "),
"email": _("Email Address"),
"address": _("Street Address"),
}Nachdem die Formulare fertig sind, definieren wir die Logik in views.py, bevor wir sie in unsere Vorlagen rendern.
4. Fügen Sie die Logik zu views.py hinzu .
Um mit in forms.py erstellten Formularen zu arbeiten, müssen Sie sie in unsere views.py importieren und einige weitere Module hinzufügen, die sich zum Erstellen von Logik als nützlich erweisen.
from django.shortcuts import render, redirect
from django.contrib.auth import authenticate, login,
from django.contrib import messages
from .models import Profile
from .forms import createUserForm, profileFormJetzt erstellen wir eine Registrierungsseite. Nennen wir es einfach registerPage . Erstellen wir ein leeres Kontextwörterbuch und geben das Rendering zurück.
def registerPage(request):
context = {}
return render(request, 'app_name/register.html', context)Weisen Sie Variablen Werte aus dem Formular zu, indem Sie die POST-Methode aufrufen. Dann übergeben wir die Variablen an das Kontextwörterbuch.
def registerPage(request):
if request.method == 'POST':
form = createUserForm(request.POST)
profile_form = profileForm(request.POST)
context = {'form': form, 'profile_form': profile_form}
return render(request, 'app_name/register.html', context)Dann werden wir beide Formulare validieren und anschließend speichern.
def registerPage(request):
if request.method == 'POST':
form = createUserForm(request.POST)
profile_form = profileForm(request.POST)
if form.is_valid() and profile_form.is_valid():
user = form.save()
#we don't save the profile_form here because we have to first get the value of profile_form, assign the user to the OneToOneField created in models before we now save the profile_form.
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
context = {'form': form, 'profile_form': profile_form}
return render(request, 'app_name/register.html', context)Wenn die Formularwerte validiert und gespeichert werden, wird eine Erfolgsmeldung angezeigt und der Benutzer zur Anmeldeseite weitergeleitet.
def registerPage(request):
if request.method == 'POST':
form = createUserForm(request.POST)
profile_form = profileForm(request.POST)
if form.is_valid() and profile_form.is_valid():
user = form.save()
#we don't save the profile_form here because we have to first get the value of profile_form, assign the user to the OneToOneField created in models before we now save the profile_form.
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
messages.success(request, 'Your account has been successfully created')
return redirect('login')
context = {'form': form, 'profile_form': profile_form}
return render(request, 'app_name/register.html', context)5. Rendern der Vorlage Erstellen Sie
in der Datei
register.htmlein Formular-Tag mit der POST-Methode und actioneinem leeren Zeichenfolgenwert. Im Formular-Tag werden csrf_tokenwir das Django-Vorlagenformat platzieren und dann die Formulare (Benutzer- und Profilformulare) dynamisch rendern. Vergessen wir auch nicht die Schaltfläche "Senden".
<form method="POST" action="">
{% csrf_token %}
<h3>Register Profile</h3>
<div class="form-field">
{{profile_form.name.label_tag}}
{{profile_form.name}}
</div>
<div class="form-field">
{{form.username.errors}}
{{form.username.label_tag}}
{{form.username}}
</div>
<div class="form-field">
{{profile_form.email.label_tag}}
{{profile_form.email}}
</div>
<div class="form-field">
{{profile_form.address.label_tag}}
{{profile_form.address}}
</div>
<div class="form-field">
{{form.password1.errors}}
{{form.password1.label_tag}}
{{form.password1}}
</div>
<div class="form-field">
{{form.password2.errors}}
{{form.password2.label_tag}}
{{form.password2}}
</div>
<hr>
<input id="form-button" class="btn btn-success btn-block" type="submit" value="Create Profile">
<br>
{{form.non_field_errors}}
<p>Already have an account? <a href="{% url 'login' %}">Login</a></p>
</form>Da wir nach dem Ausfüllen, Validieren und Speichern des Formulars zur Anmeldeseite weitergeleitet werden, wird auf der Anmeldeseite unten rechts vor der Aufschrift „Sie haben noch kein Konto? Eine Meldung über den Erfolg des Vorgangs angezeigt . Registrieren " .
<form method="POST" action="">
...
<hr>
<input id="form-button" class="btn btn-success btn-block" type="submit" value="Login">
{% for message in messages %}
<p>{{message}}</p>
{% endfor %}
<p>Don't have an account? <a href="{% url 'store:register' %}">Register</a></p>
</form>Auf diese Weise können Sie ein Profilmodell für Ihre Site erstellen, das in einer Eins-zu-Eins-Beziehung mit Ihrem Benutzermodell verknüpft ist.
