django-enregistrement semble raccourcir hashed mot de passe lors de l'utilisation sous-classée RegistrationView

Question

J'essaye de configurer le formulaire d'enregistrement de django avec un champ supplémentaire ou deux. J'ai lu la documentation et parcouru StackOverflow. Je rencontre un problème lorsque l'utilisateur est enregistré avec les nouveaux champs, mais lorsque j'essaie de me connecter, il ne reconnaît pas le mot de passe.

J'ai créé une nouvelle vue (que je viens de couper et de registre collé django-inscription parce que je veux juste courir au départ):

class MyRegistrationView (RegistrationView): 
    form_class = UserRegForm 

    def register(self, form): 
     new_user = RegistrationProfile.objects.create_inactive_user(
      form, 
      site=get_current_site(self.request) 
     ) 
     signals.user_registered.send(sender=self.__class__, 
            user=new_user, 
            request=self.request) 
     return new_user 

Il utilise cette forme:

class UserRegForm(RegistrationForm): 
    CHOICES = Institution.objects.all().order_by('name') 

    institution=forms.ChoiceField(choices=((x.id, x.name) for x in CHOICES), 
            required = True) 

Ce sont les modèles supplémentaires:

class Institution(models.Model): 
    name = models.CharField(max_length=200) 

    def __unicode__(self): 
     return u'%s' % (self.name) 

class UserProfile(models.Model): 
    user=models.OneToOneField(User, on_delete=models.CASCADE) 
    institution=models.ForeignKey(
     Institution, 
     null=True, 
     blank=True) 

    def __unicode__(self): 
     return u'%s' % (self.user) 

Mon URL

url(r'^register', views.MyRegistrationView.as_view(form_class=UserRegForm), name='registration_register'), 

Et j'ai ajouté cette option pour enregistrer les données: des modèles importer UserProfile des formes d'importation UserRegForm

def user_created(sender, user, request, **kwargs): 
    form = UserRegForm(request.POST) 

    try: data = UserProfile.objects.get(user=user) 
    except: data = UserProfile(user=user) 
    data.institution = form.data["institution"] 
    data.save() 

from registration.signals import user_registered 
user_registered.connect(user_created) 

Tout fonctionne en ce que l'utilisateur est enregistré, un e-mail est envoyé, l'institution est enregistré dans UserProfile, mais lorsque j'essaie de me connecter en utilisant le nouvel utilisateur (ayant activé le compte), il me dit que le nom d'utilisateur et le mot de passe ne correspondent pas. Quand je regarde la base de données, la chaîne de hachage paasword semble être 10 caractères plus court que les admins (configuration using manage.py createsuperuser) donc je fais quelque chose que je ne devrais pas ou ne fais pas quelque chose que je devrais faire.

L'aide serait grandement appréciée.

Answer 1

J'ai résolu ceci en copiant fondamentalement tout RegistrationView dans MyRegistrationView. Le login fonctionne maintenant bien. Je ne sais pas pourquoi c'était nécessaire.

from registration.backends.model_activation.views import RegistrationView 
from registration.models import RegistrationProfile 
from registration import signals 
from django.contrib.sites.shortcuts import get_current_site 
from django.core import signing 
from django.template.loader import render_to_string 
from django.conf import settings 
REGISTRATION_SALT = getattr(settings, 'REGISTRATION_SALT', 'registration') 

class MyRegistrationView (RegistrationView): 
    form_class = UserRegForm 
    email_body_template = 'registration/activation_email.txt' 
    email_subject_template = 'registration/activation_email_subject.txt' 

    def register(self, form): 
     new_user = self.create_inactive_user(form) 
     signals.user_registered.send(sender=self.__class__, 
            user=new_user, 
            request=self.request) 
     return new_user 

    def get_success_url(self, user): 
     return ('registration_complete',(), {}) 

    def create_inactive_user(self, form): 
     """ 
     Create the inactive user account and send an email containing 
     activation instructions. 

     """ 
     new_user = form.save(commit=False) 
     new_user.is_active = False 
     new_user.save() 

     self.send_activation_email(new_user) 

     return new_user 

    def get_activation_key(self, user): 
     """ 
     Generate the activation key which will be emailed to the user. 

     """ 
     return signing.dumps(
      obj=getattr(user, user.USERNAME_FIELD), 
      salt=REGISTRATION_SALT 
     ) 

    def get_email_context(self, activation_key): 
     """ 
     Build the template context used for the activation email. 

     """ 
     return { 
      'activation_key': activation_key, 
      'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS, 
      'site': get_current_site(self.request) 
     } 

    def send_activation_email(self, user): 
     """ 
     Send the activation email. The activation key is simply the 
     username, signed using TimestampSigner. 

     """ 
     activation_key = self.get_activation_key(user) 
     context = self.get_email_context(activation_key) 
     context.update({ 
      'user': user 
     }) 
     subject = render_to_string(self.email_subject_template, 
            context) 
     # Force subject to a single line to avoid header-injection 
     # issues. 
     subject = ''.join(subject.splitlines()) 
     message = render_to_string(self.email_body_template, 
            context) 
     user.email_user(subject, message, settings.DEFAULT_FROM_EMAIL) 

Le problème restant est-il simplement de recharger la page d'inscription plutôt que de terminer l'enregistrement?