(fields.E331) Field specifies a many-to-many relation through model 'models_groups', which has not been installed
Question: > ERRORS: login.Freelancer.groups: (fields.E331) Field specifies a many-to-
> many relation through model 'login.Freelancer_groups', which has not been
> installed. login.Freelancer.user_permissions: (fields.E331) Field specifies
> a many-to-many relation through model 'login.Freelancer_user_permissions',
> which has not been installed. message_board.Post.author: (fields.E301) Field
> defines a relation with the model 'auth.User', which has been swapped out.
> HINT: Update the relation to point at 'settings.AUTH_USER_MODEL'.

**models.py**

    
    
    from django.contrib.auth.tests.custom_user import CustomUserManager
    from django.db import models
    from django.utils import timezone
    from django.utils.http import urlquote
    from django.utils.translation import ugettext_lazy as _
    from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin
    from crm import settings
    
    
    class FreelancerManager(BaseUserManager):
        def create_user(self, name, skills, password=None):
            if not name:
                raise ValueError('Users must have a unique name ')
    
            user = self.model(
                name=self.name,
                skills=skills,
            )
            user.set_password(password)
            user.save(using=self._db)
            return user
    
        def create_superuser(self, name, skills, password):
            """
            Creates and saves a superuser with the given email, date of
            birth and password.
            """
            user = self.create_user(
                name,
                password=password,
                skills=skills,
            )
            user.is_admin = True
            user.save(using=self._db)
            return user
    
    
    class Freelancer(AbstractBaseUser, PermissionsMixin):
        name = models.CharField(verbose_name='name',
                                max_length=20,
                                unique=True, )
    
        field_of_interest = models.CharField(max_length=200)
        skills = models.TextField()
        experience = models.TextField()
    
        is_active = models.BooleanField(default=True)
        is_admin = models.BooleanField(default=False)
    
        objects = FreelancerManager()
    
        USERNAME_FIELD = 'name'
        REQUIRED_FIELDS = ['skills']
    
        class Meta:
            db_table = 'auth_user'
            verbose_name = _('user')
            verbose_name_plural = _('users')
    
        def get_absolute_url(self):
            return "/users/%s/" % urlquote(self.name)
    
        def get_short_name(self):
            return self.name
    
        def get_full_name(self):
            return self.name
    
        def __str__(self):  # __unicode__ on Python 2
            return self.name
    
        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, applabel):
            # "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 staf"
            return self.is_admin
    

**admin.py**

    
    
    from django import forms
    from django.contrib import admin
    from django.contrib.auth.models import Group
    from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
    from django.contrib.auth.forms import ReadOnlyPasswordHashField
    from .models import Freelancer
    
    
    class 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 = Freelancer
            fields = ('name', 'skills')
    
        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 user
    
    
    class 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 = Freelancer
            fields = ('name', 'password', 'skills','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 FreelancerAdmin(BaseUserAdmin):
        # 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 = ('name', 'skills', 'is_admin')
        list_filter = ('is_admin',)
        fieldsets = (
            (None, {'fields': ('name', 'password')}),
            ('Personal info', {'fields': ('skills',)}),
            ('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': ('name', 'skills', 'password1', 'password2')}
             ),
        )
        search_fields = ('name',)
        ordering = ('name',)
        filter_horizontal = ()
    
    
    # Now register the new UserAdmin...
    admin.site.register(Freelancer, FreelancerAdmin)
    admin.site.unregister(Group)
    

**settings.py**

    
    
    import os
    
    # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    
    
    # Quick-start development settings - unsuitable for production
    # See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/
    # SECURITY WARNING: keep the secret key used in production secret!
    SECRET_KEY = '&_j_tz#06jbpo5shiy62x$qxa*t68_n@q4@$pee4(a()5vyt#9'
    
    # SECURITY WARNING: don't run with debug turned on in production!
    DEBUG = True
    
    
    ALLOWED_HOSTS = []
    
    AUTH_USER_MODEL = 'auth.User'
    AUTH_USER_MODEL = 'login.Freelancer'
    # Application definition
    
    INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'login',
        'message_board'
    ]
    
    MIDDLEWARE_CLASSES = [
        'django.middleware.security.SecurityMiddleware',
        'django.contrib.sessions.middleware.SessionMiddleware',
        'django.middleware.common.CommonMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
    ]
    
    ROOT_URLCONF = 'crm.urls'
    
    TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [],
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                ],
            },
        },
    ]
    
    WSGI_APPLICATION = 'crm.wsgi.application'
    
    
    # Database
    # https://docs.djangoproject.com/en/1.9/ref/settings/#databases
    
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        }
    }
    
    # Password validation
    # https://docs.djangoproject.com/en/1.9/ref/settings/#auth-password-validators
    
    AUTH_PASSWORD_VALIDATORS = [
        {
            'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
        },
        {
            'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
        },
        {
            'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
        },
        {
            'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
        },
    ]
    
    
    # Internationalization
    # https://docs.djangoproject.com/en/1.9/topics/i18n/
    
    LANGUAGE_CODE = 'en-us'
    
    TIME_ZONE = 'Asia/Kolkata'
    
    USE_I18N = True
    
    USE_L10N = True
    
    USE_TZ = True
    
    
    # Static files (CSS, JavaScript, Images)
    # https://docs.djangoproject.com/en/1.9/howto/static-files/
    
    STATIC_URL = '/static/'
    STATIC_ROOT = os.path.join(BASE_DIR, 'static')
    

> _And i have one more named app message_board which models.py is here_

**models.py of message_board App**

    
    
    class Post(models.Model):
        author = models.ForeignKey('auth.User')
        title = models.CharField(max_length=200)
        text = models.TextField()
        created_date = models.DateTimeField(
                default=timezone.now)
        published_date = models.DateTimeField(
                blank=True, null=True)
    
        def publish(self):
            self.published_date = timezone.now()
            self.save()
    
        def __str__(self):
            return self.title
    


Answer: Its already clear from the error that there is no `auth.User` and you are
pointing `author` to it. Change that.

Either use `Freelance` or `settings.AUTH_USER_MODEL`

    
    
    from login.models import Freelancer
    
    class Post(models.Model):
        author = models.ForeignKey('settings.AUTH_USER_MODEL', on_delete=models.CASCADE)
    

