[Django] New Django 1.5 feature for completely custom user models (done by subclassing AbstractBaseUser). Coded by adhering to Django documentation recommendations. Uses django-model-utils 3rd party app, as well as multiple inheritance and string translation. Email is new primary username field.

models.py

from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin, check_password

from model_utils import Choices
from model_utils.models import TimeStampedModel


class DJManager(BaseUserManager):
    def create_user(self, email, first_name, last_name, dj_name, user_type, subscription, password=None):
        """
        Creates a new DJ user with the appropriate member-provided fields.
        """
        if not email:
            msg = 'Members must have a valid email address.'
            raise ValueError(msg)

        if not first_name:
            msg = 'Members must provide a first name.'
            raise ValueError(msg)

        if not last_name:
            msg = 'Members must provide a last name.'
            raise ValueError(msg)

        user = self.model(email=DJManager.normalize_email(email),
                          first_name=first_name,
                          last_name=last_name,
                          dj_name=dj_name,
                          user_type=user_type,
                          subscription=subscription)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, first_name, last_name, dj_name, user_type, subscription, password):
        """
        Creates a new superuser with the appropriate fields.
        """
        user = self.create_user(email=email,
                                first_name=first_name,
                                last_name=last_name,
                                dj_name=dj_name,
                                user_type=user_type,
                                subscription=subscription,
                                password=password)
        user.is_admin = True
        user.is_staff = True
        user.is_superuser = True
        user.save(using=self._db)
        return user


class DJActiveManager(models.Manager):
    def get_query_set(self):
        return super(DJActiveManager, self).get_query_set().filter(is_active=True)


class DJ(AbstractBaseUser, TimeStampedModel, PermissionsMixin):
    USER_TYPE = Choices((0, 'dj', _('DJ')), (1, 'pastor', _('Pastor')))
    SUBSCRIPTIONS = Choices((0, 'monthly', _('Monthly')),)

    email = models.EmailField(max_length=254, unique=True, db_index=True)
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    dj_name = models.CharField(max_length=200)
    user_type = models.PositiveIntegerField(choices=USER_TYPE, default=USER_TYPE.dj)
    subscription = models.PositiveIntegerField(choices=SUBSCRIPTIONS, default=SUBSCRIPTIONS.monthly)
    downloads = models.IntegerField(default=0, editable=False)

    is_approved = models.BooleanField(default=False, editable=False)
    is_active = models.BooleanField(default=False)
    is_admin = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)

    objects = DJManager()
    active = DJActiveManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name', 'dj_name', 'user_type', 'subscription']

    def get_full_name(self):
        return u'{0} {1}'.format(self.first_name, self.last_name)

    def get_short_name(self):
        return self.dj_name

    def __unicode__(self):
        return u'{0} ({1} {2})'.format(self.dj_name, self.first_name, self.last_name)


class DJBackend(object):
    """
    Authenticate a DJ user.
    """
    def authenticate(self, username=None, password=None):
        try:
            user = DJ.objects.get(email=username)
        except DJ.DoesNotExist:
            return None

        is_valid_pwd = user.check_password(password)
        if is_valid_pwd:
            return user
        else:
            return None

    def get_user(self, user_id):
        try:
            return DJ.objects.get(pk=user_id)
        except DJ.DoesNotExist:
            return None