from django.contrib.auth.models import Userclass Employee(models.Model):    user = models.OneToOneField(User)    department = models.CharField(max_length=100)

>>> u = User.objects.get(username='fsmith')>>> freds_department = u.employee.department

from django.contrib import adminfrom django.contrib.auth.admin import UserAdminfrom django.contrib.auth.models import Userfrom my_user_profile_app.models import Employee# Define an inline admin descriptor for Employee model# which acts a bit like a singletonclass EmployeeInline(admin.StackedInline):    model = Employee    can_delete = False    verbose_name_plural = 'employee'# Define a new User adminclass UserAdmin(UserAdmin):    inlines = (EmployeeInline, )# Re-register UserAdminadmin.site.unregister(User)admin.site.register(User, UserAdmin)

AUTH_USER_MODEL = 'myapp.MyUser'

from django.conf import settingsfrom django.db import modelsclass Article(models.Model):    author = models.ForeignKey(settings.AUTH_USER_MODEL)

@python_2_unicode_compatibleclass AbstractBaseUser(models.Model):    passWord = models.CharField(_('password'), max_length=128)    last_login = models.DateTimeField(_('last login'), blank=True, null=True)    is_active = True    REQUIRED_FIELDS = []    class Meta:        abstract = True    def get_username(self):        "Return the identifying username for this User"        return getattr(self, self.USERNAME_FIELD)    def __str__(self):        return self.get_username()    def natural_key(self):        return (self.get_username(),)    def is_anonymous(self):        """        Always returns False. This is a way of comparing User objects to        anonymous users.        """        return False    def is_authenticated(self):        """        Always return True. This is a way to tell if the user has been        authenticated in templates.        """        return True    def set_password(self, raw_password):        self.password = make_password(raw_password)    def check_password(self, raw_password):        """        Returns a boolean of whether the raw_password was correct. Handles        hashing formats behind the scenes.        """        def setter(raw_password):            self.set_password(raw_password)            self.save(update_fields=["password"])        return check_password(raw_password, self.password, setter)    def set_unusable_password(self):        # Sets a value that will never be a valid hash        self.password = make_password(None)    def has_usable_password(self):        return is_password_usable(self.password)    def get_full_name(self):        raise NotImplementedError('subclasses of AbstractBaseUser must provide a get_full_name() method')    def get_short_name(self):        raise NotImplementedError('subclasses of AbstractBaseUser must provide a get_short_name() method.')    def get_session_auth_hash(self):        """        Returns an HMAC of the password field.        """        key_salt = "django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash"        return salted_hmac(key_salt, self.password).hexdigest()

class MyUser(AbstractBaseUser):    identifier = models.CharField(max_length=40, unique=True)    ...    USERNAME_FIELD = 'identifier'

class MyUser(AbstractBaseUser):    ...    date_of_birth = models.DateField()    height = models.FloatField()    ...    REQUIRED_FIELDS = ['date_of_birth', 'height']

def create_user(self, email, date_of_birth, password=None):    # create user here    ...

def create_superuser(self, email, date_of_birth, password):    # create superuser here    ...

class PermissionsMixin(models.Model):    """    A mixin class that adds the fields and methods necessary to support    Django's Group and Permission model using the ModelBackend.    """    is_superuser = models.BooleanField(_('superuser status'), default=False,        help_text=_('Designates that this user has all permissions without '                    'explicitly assigning them.'))    groups = models.ManyToManyField(Group, verbose_name=_('groups'),        blank=True, help_text=_('The groups this user belongs to. A user will '                                'get all permissions granted to each of '                                'their groups.'),        related_name="user_set", related_query_name="user")    user_permissions = models.ManyToManyField(Permission,        verbose_name=_('user permissions'), blank=True,        help_text=_('Specific permissions for this user.'),        related_name="user_set", related_query_name="user")    class Meta:        abstract = True    def get_group_permissions(self, obj=None):        """        Returns a list of permission strings that this user has through their        groups. This method queries all available auth backends. If an object        is passed in, only permissions matching this object are returned.        """        permissions = set()        for backend in auth.get_backends():            if hasattr(backend, "get_group_permissions"):                permissions.update(backend.get_group_permissions(self, obj))        return permissions    def get_all_permissions(self, obj=None):        return _user_get_all_permissions(self, obj)    def has_perm(self, perm, obj=None):        """        Returns True if the user has the specified permission. This method        queries all available auth backends, but returns immediately if any        backend returns True. Thus, a user who has permission from a single        auth backend is assumed to have permission in general. If an object is        provided, permissions for this specific object are checked.        """        # Active superusers have all permissions.        if self.is_active and self.is_superuser:            return True        # Otherwise we need to check the backends.        return _user_has_perm(self, perm, obj)    def has_perms(self, perm_list, obj=None):        """        Returns True if the user has each of the specified permissions. If        object is passed, it checks if the user has all required perms for this        object.        """        for perm in perm_list:            if not self.has_perm(perm, obj):                return False        return True    def has_module_perms(self, app_label):        """        Returns True if the user has any permissions in the given app label.        Uses pretty much the same logic as has_perm, above.        """        # Active superusers have all permissions.        if self.is_active and self.is_superuser:            return True        return _user_has_module_perms(self, app_label)

class AbstractUser(AbstractBaseUser, PermissionsMixin):    """    An abstract base class implementing a fully featured User model with    admin-compliant permissions.    Username, password and email are required. Other fields are optional.    """    username = models.CharField(_('username'), max_length=30, unique=True,        help_text=_('Required. 30 characters or fewer. Letters, digits and '                    '@/./+/-/_ only.'),        validators=[            validators.RegexValidator(r'^[/w.@+-]+$',                                      _('Enter a valid username. '                                        'This value may contain only letters, numbers '                                        'and @/./+/-/_ characters.'), 'invalid'),        ],        error_messages={            'unique': _("A user with that username already exists."),        })    first_name = models.CharField(_('first name'), max_length=30, blank=True)    last_name = models.CharField(_('last name'), max_length=30, blank=True)    email = models.EmailField(_('email address'), blank=True)    is_staff = models.BooleanField(_('staff status'), default=False,        help_text=_('Designates whether the user can log into this admin '                    'site.'))    is_active = models.BooleanField(_('active'), default=True,        help_text=_('Designates whether this user should be treated as '                    'active. Unselect this instead of deleting accounts.'))    date_joined = models.DateTimeField(_('date joined'), default=timezone.now)    objects = UserManager()    USERNAME_FIELD = 'username'    REQUIRED_FIELDS = ['email']    class Meta:        verbose_name = _('user')        verbose_name_plural = _('users')        abstract = True    def get_full_name(self):        """        Returns the first_name plus the last_name, with a space in between.        """        full_name = '%s %s' % (self.first_name, self.last_name)        return full_name.strip()    def get_short_name(self):        "Returns the short name for the user."        return self.first_name    def email_user(self, subject, message, from_email=None, **kwargs):        """        Sends an email to this User.        """        send_mail(subject, message, from_email, [self.email], **kwargs)class User(AbstractUser):    """    Users within the Django authentication system are represented by this    model.    Username, password and email are required. Other fields are optional.    """    class Meta(AbstractUser.Meta):        swappable = 'AUTH_USER_MODEL'

from django.db import modelsfrom django.contrib.auth.models import (    BaseUserManager, AbstractBaseUser)class MyUserManager(BaseUserManager):    def create_user(self, email, date_of_birth, password=None):        """        Creates and saves a User with the given email, date of        birth and password.        """        if not email:            raise ValueError('Users must have an email address')        user = self.model(            email=self.normalize_email(email),            date_of_birth=date_of_birth,        )        user.set_password(password)        user.save(using=self._db)        return user    def create_superuser(self, email, date_of_birth, password):        """        Creates and saves a superuser with the given email, date of        birth and password.        """        user = self.create_user(email,            password=password,            date_of_birth=date_of_birth        )        user.is_admin = True        user.save(using=self._db)        return userclass MyUser(AbstractBaseUser):    email = models.EmailField(        verbose_name='email address',        max_length=255,        unique=True,    )    date_of_birth = models.DateField()    is_active = models.BooleanField(default=True)    is_admin = models.BooleanField(default=False)    objects = MyUserManager()    USERNAME_FIELD = 'email'    REQUIRED_FIELDS = ['date_of_birth']    def get_full_name(self):        # The user is identified by their email address        return self.email    def get_short_name(self):        # The user is identified by their email address        return self.email    def __str__(self):              # __unicode__ on Python 2        return self.email    def has_perm(self, perm, obj=None):        "Does the user have a specific permission?"        # Simplest possible answer: Yes, always        return True    def has_module_perms(self, app_label):        "Does the user have permissions to view the app `app_label`?"        # Simplest possible answer: Yes, always        return True    @property    def is_staff(self):        "Is the user a member of staff?"        # Simplest possible answer: All admins are staff        return self.is_admin

from django import formsfrom django.contrib import adminfrom django.contrib.auth.models import Groupfrom django.contrib.auth.admin import UserAdminfrom django.contrib.auth.forms import ReadOnlyPasswordHashFieldfrom customauth.models import MyUserclass UserCreationForm(forms.ModelForm):    """A form for creating new users. Includes all the required    fields, plus a repeated password."""    password1 = forms.CharField(label='Password', widget=forms.PasswordInput)    password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)    class Meta:        model = MyUser        fields = ('email', 'date_of_birth')    def clean_password2(self):        # Check that the two password entries match        password1 = self.cleaned_data.get("password1")        password2 = self.cleaned_data.get("password2")        if password1 and password2 and password1 != password2:            raise forms.ValidationError("Passwords don't match")        return password2    def save(self, commit=True):        # Save the provided password in hashed format        user = super(UserCreationForm, self).save(commit=False)        user.set_password(self.cleaned_data["password1"])        if commit:            user.save()        return userclass UserChangeForm(forms.ModelForm):    """A form for updating users. Includes all the fields on    the user, but replaces the password field with admin's    password hash display field.    """    password = ReadOnlyPasswordHashField()    class Meta:        model = MyUser        fields = ('email', 'password', 'date_of_birth', 'is_active', 'is_admin')    def clean_password(self):        # Regardless of what the user provides, return the initial value.        # This is done here, rather than on the field, because the        # field does not have access to the initial value        return self.initial["password"]class MyUserAdmin(UserAdmin):    # The forms to add and change user instances    form = UserChangeForm    add_form = UserCreationForm    # The fields to be used in displaying the User model.    # These override the definitions on the base UserAdmin    # that reference specific fields on auth.User.    list_display = ('email', 'date_of_birth', 'is_admin')    list_filter = ('is_admin',)    fieldsets = (        (None, {'fields': ('email', 'password')}),        ('Personal info', {'fields': ('date_of_birth',)}),        ('Permissions', {'fields': ('is_admin',)}),    )    # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin    # overrides get_fieldsets to use this attribute when creating a user.    add_fieldsets = (        (None, {            'classes': ('wide',),            'fields': ('email', 'date_of_birth', 'password1', 'password2')}        ),    )    search_fields = ('email',)    ordering = ('email',)    filter_horizontal = ()# Now register the new UserAdmin...admin.site.register(MyUser, MyUserAdmin)# ... and, since we're not using Django's built-in permissions,# unregister the Group model from admin.admin.site.unregister(Group)

AUTH_USER_MODEL = 'customauth.MyUser'