Comment personnaliser le profil utilisateur lors de l'utilisation de django-allauth

J'ai un projet django avec l'application django-allauth. J'ai besoin de collecter des données supplémentaires auprès de l'utilisateur lors de l'inscription. Je suis tombé sur une question similaire ici mais malheureusement, personne n'a répondu à la partie personnalisation du profil.

Selon la documentation fournie pourdjango-allauth :

ACCOUNT_SIGNUP_FORM_CLASS(= None)

Une chaîne pointant vers une classe de formulaire personnalisée (par exemple ‘myapp.forms.SignupForm’) qui est utilisée lors de l'inscription pour demander à l'utilisateur une entrée supplémentaire (par exemple, inscription à la newsletter, date de naissance). Cette classe doit implémenter une ‘save’méthode, en acceptant l'utilisateur nouvellement inscrit comme seul paramètre.

Je suis nouveau sur Django et j'ai du mal avec ça. Quelqu'un peut-il fournir un exemple d'une telle classe de formulaire personnalisée? Dois-je également ajouter une classe de modèle avec un lien vers l'objet utilisateur comme celui-ci ?

Supposons que vous souhaitiez demander à l'utilisateur son prénom / nom lors de l'inscription. Vous devrez mettre ces champs dans votre propre formulaire, comme ceci:

class SignupForm(forms.Form):
    first_name = forms.CharField(max_length=30, label='Voornaam')
    last_name = forms.CharField(max_length=30, label='Achternaam')

    def signup(self, request, user):
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        user.save()

Ensuite, dans vos paramètres, pointez sur ce formulaire:

ACCOUNT_SIGNUP_FORM_CLASS = 'yourproject.yourapp.forms.SignupForm'

C'est tout.

En utilisant la solution suggérée par pennersr, je recevais un avertissement de dépréciation:

DeprecationWarning: The custom signup form must offer a def signup(self, request, user) method DeprecationWarning)

En effet, à partir de la version 0.15, la méthode de sauvegarde a été déconseillée au profit d'une méthode d'inscription def (requête, utilisateur).

Donc, pour résoudre cela, le code de l'exemple devrait être comme ceci:

class SignupForm(forms.Form):
    first_name = forms.CharField(max_length=30, label='Voornaam')
    last_name = forms.CharField(max_length=30, label='Achternaam')

    def signup(self, request, user):
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        user.save()

Voici ce qui a fonctionné pour moi en combinant quelques-unes des autres réponses (aucune d'entre elles n'est complète à 100% et sèche).

Dans yourapp/forms.py:

from django.contrib.auth import get_user_model
from django import forms

class SignupForm(forms.ModelForm):
    class Meta:
        model = get_user_model()
        fields = ['first_name', 'last_name']

    def signup(self, request, user):
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        user.save()

Et dans settings.py:

ACCOUNT_SIGNUP_FORM_CLASS = 'yourapp.forms.SignupForm'

De cette façon, il utilise les formulaires modèles pour qu'il soit SEC, et utilise le nouveau def signup. J'ai essayé de mettre 'myproject.myapp.forms.SignupForm'mais cela a entraîné une erreur en quelque sorte.

@Shreyas: La solution ci-dessous n'est peut-être pas la plus propre, mais elle fonctionne. S'il vous plaît laissez-moi savoir si vous avez des suggestions pour le nettoyer davantage.

Pour ajouter des informations qui n'appartiennent pas au profil utilisateur par défaut, créez d'abord un modèle dans yourapp / models.py. Lisez la documentation générale de django pour en savoir plus, mais en gros:

from django.db import models

class UserProfile(models.Model):
    user = models.OneToOneField(User, related_name='profile')
    organisation = models.CharField(organisation, max_length=100, blank=True)

Créez ensuite un formulaire dans yourapp / forms.py:

from django import forms

class SignupForm(forms.Form):
    first_name = forms.CharField(max_length=30, label='Voornaam')
    last_name = forms.CharField(max_length=30, label='Achternaam')
    organisation = forms.CharField(max_length=20, label='organisation')

    def signup(self, request, user):
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        # Replace 'profile' below with the related_name on the OneToOneField linking back to the User model
        up = user.profile
        up.organisation = self.cleaned_data['organisation']
        user.save()
        up.save()

Dans votre users/forms.pyvous mettez:

from django.contrib.auth import get_user_model
class SignupForm(forms.ModelForm):
    class Meta:
        model = get_user_model()
        fields = ['first_name', 'last_name']
    def save(self, user):
        user.save()

Dans settings.py vous mettez:

ACCOUNT_SIGNUP_FORM_CLASS = 'users.forms.SignupForm'

De cette façon, vous ne cassez pas le principe DRY par la multiplicité de la définition des champs des modèles utilisateur.

J'ai essayé de nombreux tutoriels différents et il leur manque quelque chose, répéter du code inutile ou faire des choses bizarres, ci-dessous suit ma solution qui rejoint toutes les options que j'ai trouvées, ça marche, je l'ai déjà mis en production MAIS ça toujours pas me convaincre parce que je m'attendrais à recevoir le prénom et le nom dans les fonctions que j'ai attachées aux utilisateurs créent pour éviter de créer un profil à l'intérieur du formulaire, mais je ne pourrais pas, par ailleurs, je pense que cela vous aidera.

Models.py

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(max_length=500, blank=True)
    nationality = models.CharField(max_length=2, choices=COUNTRIES)
    gender = models.CharField(max_length=1, choices=GENDERS)

def __str__(self):
    return self.user.first_name


@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)

@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

Forms.py

class SignupForm(forms.ModelForm):
    first_name = forms.CharField(max_length=100)
    last_name = forms.CharField(max_length=100)

    class Meta:
        model = Profile
        fields = ('first_name', 'last_name', 'nationality', 'gender')

    def signup(self, request, user):
        # Save your user
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        user.save()

        user.profile.nationality = self.cleaned_data['nationality']
        user.profile.gender = self.cleaned_data['gender']
        user.profile.save()

Settings.py

ACCOUNT_SIGNUP_FORM_CLASS = 'apps.profile.forms.SignupForm'

#models.py

from django.conf import settings

class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    image = models.ImageField(default='users/default.png', upload_to='users')
    fields = models.ForeignKey('Field' ,null=True ,on_delete=models.SET_NULL)
    category = models.ForeignKey('Category' ,null=True ,on_delete=models.SET_NULL)
    description = models.TextField()
    interests = models.ManyToManyField('Interests')

    ...

   def save(self, *args, **kwargs):
       super().save(*args, **kwargs)

...

def userprofile_receiver(sender, instance, created, *args, **kwargs):
    if created:
        userprofile = UserProfile.objects.create(user=instance)
    else:
        instance.userprofile.save()

post_save.connect(userprofile_receiver, sender=settings.AUTH_USER_MODEL)



 #forms.py

 class SignupForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super(SignupForm, self).__init__(*args, **kwargs)
        self.fields['first_name'].widget = forms.TextInput(attrs={'placeholder': 'Enter first name'})
        self.fields['last_name'].widget = forms.TextInput(attrs={'placeholder': 'Enter last name'})

    first_name = forms.CharField(max_length=100)
    last_name = forms.CharField(max_length=100)

    interests  = forms.ModelMultipleChoiceField(widget=forms.CheckboxSelectMultiple, help_text="Choose your interests", queryset=Interests.objects.all())

    image = forms.ImageField(help_text="Upload profile image ")
    fields = forms.ChoiceField(help_text="Choose your fields ")
    category = forms.ChoiceField(help_text="Choose your category")

    class Meta:
        model = UserProfile
        fields = ('first_name', 'last_name',  'name', 'image', 'fields', 'category', 'description', 'phone', 'facebook', 'twitter', 'skype', 'site', 'address', 'interests' ,'biography')
        widgets = {
             ...
            'description': forms.TextInput(attrs={'placeholder': 'Your description'}),
            'address': forms.TextInput(attrs={'placeholder': 'Enter address'}),
            'biography': forms.TextInput(attrs={'placeholder': 'Enter biography'}),
            ....
    }
    def signup(self, request, user):
        # Save your user
        user.first_name = self.cleaned_data['first_name']
        user.last_name = self.cleaned_data['last_name']
        user.save()

        user.userprofile.image = self.cleaned_data.get('image')
        user.userprofile.fields = self.cleaned_data['fields']
        user.userprofile.category = self.cleaned_data['category']
        user.userprofile.description = self.cleaned_data['description']
        interests = self.cleaned_data['interests']
        user.userprofile.interests.set(interests)
        user.userprofile.save()


# settings.py or base.py

ACCOUNT_SIGNUP_FORM_CLASS = 'nameApp.forms.SignupForm'

C'est ça. (:

Créer un modèle de profil avec l'utilisateur comme OneToOneField

class Profile(models.Model):
    user = models.OneToOneField(User, verbose_name=_('user'), related_name='profiles')
    first_name=models.CharField(_("First Name"), max_length=150)
    last_name=models.CharField(_("Last Name"), max_length=150)
    mugshot = ImageField(_('mugshot'), upload_to = upload_to, blank=True)
    phone= models.CharField(_("Phone Number"), max_length=100)
    security_question = models.ForeignKey(SecurityQuestion, related_name='security_question')
    answer=models.CharField(_("Answer"), max_length=200)
    recovery_number= models.CharField(_("Recovery Mobile Number"), max_length=100)
    city=models.ForeignKey(City,related_name='city', blank=True, null=True, help_text=_('Select your City'))
    location=models.ForeignKey(Country,related_name='location', blank=True, null=True, help_text=_('Select your Location'))