Add support for a truly custom User model

The new model must have an email field but Oscar will work without
anything else.

oscar/apps/customer/auth_backends.py

 
 User = get_user_model()
 
-if hasattr(User, 'REQUIRED_FIELDS') and 'email' not in User.REQUIRED_FIELDS:
-    raise ImproperlyConfigured("Emailbackend: Your User model must have an email"
-                               " field with blank=False")
+if hasattr(User, 'REQUIRED_FIELDS'):
+    if not (User.USERNAME_FIELD == 'email' or 'email' in User.REQUIRED_FIELDS):
+        raise ImproperlyConfigured(
+            "Emailbackend: Your User model must have an email"
+            " field with blank=False")
 
 
 class Emailbackend(ModelBackend):
+    """
+    Custom auth backend that users an email address
+
+    For this to work, the User model must have an 'email' field
+    """
 
     def authenticate(self, email=None, password=None, *args, **kwargs):
         if email is None:

oscar/apps/customer/forms.py

 if Profile:
 
     class UserAndProfileForm(forms.ModelForm):
-        first_name = forms.CharField(
-            label=_('First name'), max_length=128, required=False)
-        last_name = forms.CharField(
-            label=_('Last name'), max_length=128, required=False)
         email = forms.EmailField(label=_('Email address'), required=True)
 
-        # Fields from user model
-        user_fields = ('first_name', 'last_name', 'email')
-
         def __init__(self, user, *args, **kwargs):
             self.user = user
             try:
 
             super(UserAndProfileForm, self).__init__(*args, **kwargs)
 
-            # Add user fields
-            self.fields['first_name'].initial = self.instance.user.first_name
-            self.fields['last_name'].initial = self.instance.user.last_name
+            # Get a list of profile fields to help with ordering later
+            profile_field_names = self.fields.keys()
+            del profile_field_names[profile_field_names.index('email')]
+
             self.fields['email'].initial = self.instance.user.email
 
-            # Ensure user fields are above profile
-            order = list(self.user_fields)
-            for field_name in self.fields.keys():
-                if field_name not in self.user_fields:
-                    order.append(field_name)
-            self.fields.keyOrder = order
+            # Add user fields (we look for core user fields first)
+            core_field_names = set([f.name for f in User._meta.fields])
+            user_field_names = ['email']
+            for field_name in ('first_name', 'last_name'):
+                if field_name in core_field_names:
+                    user_field_names.append(field_name)
+            user_field_names.extend(User._meta.additional_fields)
+
+            # Store user fields so we know what to save later
+            self.user_field_names = user_field_names
+
+            # Add additional user fields
+            additional_fields = forms.fields_for_model(
+                User, fields=user_field_names)
+            self.fields.update(additional_fields)
+
+            # Set initial values
+            for field_name in user_field_names:
+                self.fields[field_name].initial = getattr(user, field_name)
+
+            # Ensure order of fields is email, user fields then profile fields
+            self.fields.keyOrder = user_field_names + profile_field_names
 
         class Meta:
             model = Profile
 
         def save(self, *args, **kwargs):
             user = self.instance.user
-            user.first_name = self.cleaned_data['first_name']
-            user.last_name = self.cleaned_data['last_name']
-            user.email = self.cleaned_data['email']
+
+            # Save user also
+            for field_name in self.user_field_names:
+                setattr(user, field_name, self.cleaned_data[field_name])
             user.save()
+
             return super(ProfileForm, self).save(*args, **kwargs)
 
     ProfileForm = UserAndProfileForm

oscar/apps/customer/views.py

 ProductAlert = get_model('customer', 'ProductAlert')
 User = get_user_model()
 
+
 class LogoutView(RedirectView):
     url = '/'
     permanent = False
     def get_profile_fields(self, user):
         field_data = []
 
+        # Check for custom user model
+        for field_name in User._meta.additional_fields:
+            field_data.append(
+                self.get_model_field_data(user, field_name))
+
         # Check for profile class
         profile_class = get_profile_class()
         if profile_class:
                 field_data.append(
                     self.get_model_field_data(profile, field_name))
 
-        # Check for custom user model
-        for field_name in User._meta.additional_fields:
-            field_data.append(
-                self.get_model_field_data(user, field_name))
-
         return field_data
 
     def get_model_field_data(self, model_class, field_name):

oscar/templates/oscar/customer/profile.html

             </div>
             <table class="table table-striped table-bordered">
                 <tbody>
-                    <tr>
-                        <th>{% trans 'Name' %}</th>
-                        <td>{{ request.user.get_full_name|default:'-' }}</td>
-                    </tr>
                     <tr>
                         <th>{% trans 'Email address' %}</th>
                         <td>{{ user.email }}</td>
                         </tr>
                         {% endfor %}
                     {% endblock %}
-                    <tr>
-                        <th>{% trans 'Date registered' %}</th>
-                        <td>{{ user.date_joined }}</td>
-                    </tr>
+                    {% if user.date_joined %}
+                        <tr>
+                            <th>{% trans 'Date registered' %}</th>
+                            <td>{{ user.date_joined }}</td>
+                        </tr>
+                    {% endif %}
                 </tbody>
             </table>
 

sites/sandbox/apps/user/models.py

 from django.db import models
+from django.utils import timezone
 
 from django.contrib.auth import models as auth_models
 
 
 
 # A simple extension of the core User model
-class CustomUserModel(auth_models.AbstractUser):
+class ExtendedUserModel(auth_models.AbstractUser):
     twitter_username = models.CharField(max_length=255, unique=True)
+
+
+class CustomUserManager(auth_models.BaseUserManager):
+
+    def create_user(self, email, password=None):
+        now = timezone.now()
+        email = auth_models.BaseUserManager.normalize_email(email)
+        user = self.model(email=email, last_login=now)
+        user.set_password(password)
+        user.save(using=self._db)
+        return user
+
+    def create_superuser(self, email, password):
+        return self.create_user(email, password)
+
+
+# A user model which doesn't extend AbstractUser
+class CustomUserModel(auth_models.AbstractBaseUser):
+    name = models.CharField(max_length=255, blank=True)
+    email = models.EmailField(unique=True)
+    twitter_username = models.CharField(max_length=255, unique=True)
+
+    USERNAME_FIELD = 'email'
+
+    objects = CustomUserManager()
+
+    def __unicode__(self):
+        return self.email
+
+    def get_full_name(self):
+        return self.name
+
+    get_short_name = get_full_name