多种用户类型注册（Django）

Question

I'm new to Django and I've read many topics about authentication but I can't still figure out what is the best (or most used) way to set more account types in Django to be able to make different registrations.

Real Example:

I want to create a web page which is dedicated to provide communication and other services between customers and sellers (in this case people who translate across many languages).

The main point is this:

The web should be of course different for those two types of users . Customer should not have to fill in forms like languages or price per hour during registration.

Another thing is that Seller should have access to pages like "Opened jobs" etc. and Customer should have access to pages like "Estimate price", "Upload text to translate" and many others.

I've already these models:

class Language(models.Model):
    shortcut = models.CharField(max_length=6)
    name = models.CharField(max_length=50)
    price_per_sign = models.FloatField()

class BaseUser(AbstractUser):
    # username = models.CharField(max_length=50)
    # email = models.EmailField(unique=True)
    # first_name = models.CharField(max_length=50)
    # surname = models.CharField(max_length=50)
    telephone = models.CharField(max_length=50)

class TranslatorUser(BaseUser):
    languages = models.ManyToManyField(Language)

    class Meta:
        verbose_name = 'Translator'
        verbose_name_plural = 'Translators'

class CustomerUser(BaseUser):
    spent = models.FloatField()

    class Meta:
        verbose_name = 'Customer'
        verbose_name_plural = 'Customers'

How to create a registration forms for both Customer and Translator?

This is my forms.py:

    class TranslatorUserRegistrationForm(UserCreationForm):
        username = forms.CharField(required=True)
        email = forms.EmailField(required=True)

        class Meta:
            model = User
            fields = ['email','username']

        def save(self, commit=True):
            user = super(TranslatorUserRegistrationForm,self).save(commit=True)
            translator = TranslatorUser(user=user,email=self.cleaned_data['email'],username=self.cleaned_data['username'])
            translator.save()
            return user, translator

And views.py:

def register_translator(request):
    form = TranslatorUserRegistrationForm()
    if request.method==['POST']:

        form = TranslatorUserRegistrationForm(request.POST)

    else: return render(request,'registration/register_form.html',{'registration_form':form})

When I try to make migrations, it returns this error:

ERRORS:
auth.User.groups: (fields.E304) Reverse accessor for 'User.groups' clashes with
reverse accessor for 'BaseUser.groups'.
        HINT: Add or change a related_name argument to the definition for 'User.
groups' or 'BaseUser.groups'.
auth.User.user_permissions: (fields.E304) Reverse accessor for 'User.user_permis
sions' clashes with reverse accessor for 'BaseUser.user_permissions'.
        HINT: Add or change a related_name argument to the definition for 'User.
user_permissions' or 'BaseUser.user_permissions'.
auth_test.BaseUser.groups: (fields.E304) Reverse accessor for 'BaseUser.groups'
clashes with reverse accessor for 'User.groups'.
        HINT: Add or change a related_name argument to the definition for 'BaseU
ser.groups' or 'User.groups'.
auth_test.BaseUser.user_permissions: (fields.E304) Reverse accessor for 'BaseUse
r.user_permissions' clashes with reverse accessor for 'User.user_permissions'.
        HINT: Add or change a related_name argument to the definition for 'BaseU
ser.user_permissions' or 'User.user_permissions'.

Answer 1

Solution that I'm using is based on Profile models. Those are models that will extend normal user model (by one to one relation) and won't contain authentication data. That type of models are described in django docs, but they are made simply by OneToOneField .

I'm using solution based on model inheritance. In django models that aren't abstract also can be inherited, django will under the hood create OneToOneField in child model pointing to parent model. That field will also be used as an primary key, so ID of child model will always be same as it's parent. Also, you will be able to access parent fields from child models (like they we're here!).

So in other words, you should create 2 models (one for each type of user) that will inherit from standard User model (or customized one, but it can't be abstract) and for each registered user you will create object from one of that models.

For easy use, you can create middleware that will automatically detect type of user and swap user model in request object to specialized one.