More than one profile in Django?

Is it possible to use Django's user authentication features with more than one profile?

Currently I have a settings.py file that has this in it:

AUTH_PROFILE_MODULE = 'auth.UserProfileA'

and a models.py file that has this in it:

from django.db import models
from django.contrib.auth.models import User

class UserProfileA(models.Model):
    company = models.CharField(max_length=30)
    user = models.ForeignKey(User, unique=True)

that way, if a user logs in, I can easily get the profile because the User has a get_profile() method. However, I开发者_开发问答 would like to add UserProfileB. From looking around a bit, it seems that the starting point is to create a superclass to use as the AUTH_PROFILE_MODULE and have both UserProfileA and UserProfileB inherit from that superclass. The problem is, I don't think the get_profile() method returns the correct profile. It would return an instance of the superclass. I come from a java background (polymorphism) so I'm not sure exactly what I should be doing.

Thanks!

Edit:

Well I found a way to do it via something called an "inheritance hack" that I found at this site http://djangosnippets.org/snippets/1031/

It works really well, however, coming from a java background where this stuff happens automatically, I'm a little unsettled by the fact that someone had to code this up and call it a "hack" to do it in python. Is there a reason why python doesn't enable this?

---

So the issue you're going to have is that whatever you want for your profile, you need to persist it in a database of some sort. Basically all of the back-ends for django are relational, and thus every field in a persisted object is present in every row of the table. there are a few ways for getting what you want.

Django provides some support for inheritance. You can use the techniques listed and get reasonable results in a polymorphic way.

The most direct approach is to use multiple table inheritance. Roughly:

class UserProfile(models.Model):
    # set settings.AUTH_PROFILE_MODULE to this class!
    pass

class UserProfileA(UserProfile):
    pass

class UserProfileB(UserProfile):
    pass

To use it:

try:
    profile = user.get_profile().userprofilea
    # user profile is UserProfileA
except UserProfileA.DoesNotExist:
    # user profile wasn't UserProfileB
    pass
try:
    profile = user.get_profile().userprofileb
    # user profile is UserProfileB
except UserProfileB.DoesNotExist:
    # user profile wasn't either a or b...

Edit: Re, your comment.

The relational model implies a number of things that seem to disagree with object oriented philosophy. For a relation to be useful, it requires that every element in the relation to have the same dimensions, so that relational queries are valid for the whole relation. Since this is known a-priori, before encountering an instance of a class stored in the relation, then the row cannot be a subclass. django's orm overcomes this impedance mismatch by storing the subclass information in a different relation (one specific to the subclass), There are other solutions, but they all obey this basic nature of the relational model.

If it helps you come to terms with this, I'd suggest looking at how persistence on a RDBMs works for applications in the absence of an ORM. In particular, relational databases are more about collections and summaries of many rows, rather than applying behaviors to data once fetched from the database.

The specific example of using the profile feature of django.contrib.auth is a rather uninteresting one, especially if the only way that model is ever used is to fetch the profile data associated with a particular django.contrib.auth.models.User instance. If there are no other queries, you don't need a django.models.Model subclass at all. You can pickle a regular python class and store it in a blob field of an otherwise featureless model.

On the other hand, if you want to do more interesting things with profiles, like search for users that live in a particular city, then it will be important for all profiles to have an index for their city property. That's got nothing to do with OOP, and everything to do with relational.

---

The idios app by the Pinax team aimed at solving the multiple-profile problem. You can tweak the model to make the inheritance of the base profile class either abstract or non-abstract. https://github.com/eldarion/idios.

---

Here is the answer to my question of how to get multiple profiles to work:

from django.contrib.contenttypes.models import ContentType
class Contact(models.Model):

    content_type = models.ForeignKey(ContentType,editable=False,null=True)

    def save(self):
        if(not self.content_type):
            self.content_type = ContentType.objects.get_for_model(self.__class__)
        self.save_base()

    def as_leaf_class(self):
        content_type = self.content_type
        model = content_type.model_class()
        if(model == Contact):
            return self
        return model.objects.get(id=self.id)

I don't really understand why it works or why the developers of django/python made inheritance work this way

---

If you have app-specific options for each user, I would rather recommend to put them into a separate model.

A simplified example:

class UserSettings(models.Model):
    user = models.ForeignKey(User, primary_key = True)

    # Settings go here
    defaultLocale = models.CharField(max_length = 80, default = "en_US")
    ...

This would be used like so:

def getUserSettings(request):
    try:
        return UserSettings.objects.get(pk = request.user)
    except UserSettings.DoesNotExist:
        # Use defaults instead, that's why you should define reasonable defaults
        # in the UserSettings model
        return UserSettings()