[Django]-RelatedObjectDoesNotExist: User has no userprofile

If you are getting this error even if you’ve tried the suggestions above, it may caused by the fact that the first user you had created (with createsuperuser command) does not have a profile.

I was getting this error when I tried to login with that user. I solved it this way:

-Create a new user.

-Undo the changes. (Erase the code you’ve written for Profile or make them comment lines)

-Log in to your superuser.

-Give admin authorization to newly created user.

Now you can delete the first user. (The user with no profile)

Nothing in what you’ve done forces the creation of a UserProfile object when a User is created. There are two basic ways of handling this:

1. If you always want a UserProfile to exist (which seems like the case as you give a default value to score, create a post_save handler that creates a new profile when ever the User object is created (but not every time it’s saved, so make sure to check the created argument in the handler).

2. If it’s expected a user may not have a profile, you need to catch the UserProfile.DoesNotExist exception when trying to access it. If you do this frequently, make some kind of helper function.

UPDATED TO ANSWER SIGNAL QUESTION

It also looks like somewhere around here post_save.connect(create_profile, sender=User) should be added?

You would need to define a function called create_profile and then wire it up as you have shown. I typically do this right in the models.py file that includes the sender but in this case where the sender is a built-in Django model and you’re already importing that model into the file where you define your UserProfile that’s the place to do it. It would look something like:

def create_profile(sender, instance, created, *args, **kwargs):
    # ignore if this is an existing User
    if not created:
        return
    UserProfile.objects.create(user=instance)
post_save.connect(create_profile, sender=User)

I had the same problem (= User exists, Profile does not but there is OneToOne relation introduced from Profile side) so I could not log in to Admin site. The app was already in production, and I could not trash the database.

The solution was to create a temporary view function fixme with no login requirements (but a hard-to-guess URL) and visit it once. The view queried for all User objects, and then reverse-queried for the Profile of each User with get_or_create(). If Profile was not there, it was created.

Print was for monitoring success through logs. Finally removed the view and URL from the production app.

def fixme(request):
    users = User.objects.all()
    for user in users:
        obj, created = Profile.objects.get_or_create(user=user)
        print(user.username,' : ',created)
    print("all done")
    return HttpResponse("It's done.")

First Register profile model in admin.py if not already done.

Create new superuser using ./manage.py createsuperuser.

Log in with new superuser.

From Admin panel click Profile and add new entry and selct user from user dropdown and save.

I solve this problem (Django 3.8.3-Mongodb). Firstly, I created signals.py, then I added apps.py in project.

signals.py

from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User
from .models import Profile

@receiver(post_save,sender=User)
def update_user_profile(sender,instance,created,**kwargs):
    if created:
        profile = Profile.objects.create(user =instance)

apps.py

from django.apps import AppConfig


class ProfileConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'Profile'

    def ready(self):
        import Profile.signals

views.py

from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.urls.base import reverse
from .forms import ProfileForm
from .models import Profile
from django.shortcuts import redirect, render,get_object_or_404
from django.contrib.auth import update_session_auth_hash
from django.contrib.auth.forms import PasswordChangeForm

login_required(login_url="user:login")
def dashboard(request):
    return render(request,"dashboard.html")


@login_required(login_url="user:login")
def get_profile(request):    
    
    profile = get_object_or_404(Profile,user=request.user)
    
    return render(request,"profile.html",{"profile":profile})

@login_required(login_url="user:login")
def update_profile(request):       
    profile = get_object_or_404(Profile, user=request.user)
    form = ProfileForm(instance=profile)
    if request.method=="POST":
        form = ProfileForm(request.POST,request.FILES,instance=request.user.user_profile)
        if form.is_valid():
            form.save()
            messages.success(request,"Profile is updated successfully")
            return HttpResponseRedirect(reverse("profile:profile"))   
        else:
            return render(request,"profile.html",{"form":form})                 
            
    return render(request,"edit.html",{"form":form})

I had the same error but i solved it by creating my signals example below

then i edited my apps.py as follows:

`from django.apps import AppConfig

class BlogConfig(AppConfig):
default_auto_field = ‘django.db.models.BigAutoField’
name = ‘app_name’

def ready(self):
    import app_name.signals`

Answering your updated question. There is already a save() method in models and it gets called every time you save a model (in your case when you call create_user()). So all you need to do is define a handler function and connect it to the post_save signal.

def create_extension(sender, instance, created, *args, **kwargs):
    if created:
        # do your thing

models.signals.post_save.connect(create_extension, sender=User, dispatch_uid='create_extension')

I usually put the handler functions into a separate file signals.py and add connect() statements at the end of models.py

Just try to create a new user using shell to get access to the admin page then create a profile from admin page for the old user : python manage.py createsuperuser

To access to shell, inside your directory project ine terminall type :
python manage.py shell

I’m a bit kinda late for this but ill just, share the solution that worked for me on Django 3.0.8…

Error : RelatedObjectDoesNotExist: User has no profile

This the is where my error was directing me to :

@login_required
def dashboard(request):
    if request.method == 'POST':
        user_form = UserEditForm(instance=request.user, data=request.POST)
        profile_form = ProfileEditForm(instance=request.user.profile, data=request.POST, files=request.FILES)

Note: You have to login or your profile to be saved.

Just after creating your account, you should be able to see that you are not logged in and you will have to log in to for your profile be saved and to start working.

Go inside your views, at your create_user function and do these

profile = userprofile()
profile.user = user
profile.save()

I had similar problems and after 3 days of research, I was able to sort this with just the above 3 lines of codes.

The problem is that your superuser isn’t connected to a userprofile.
There are one of the many ways to fix this, one is creating the user from a shell

py manage.py shell

> from django.contrib.auth.models import User
> 
> user=User.objects.create_user('UserName', password='AdminPassword')
> user.is_superuser=True   
> user.is_staff=True   
> user.save()
> exit()

And another way around being, you can add the following code in the Models.py so that the superuser you create is added to the scope of UserProfile.

User.userprofile = property(lambda
u:Userprofile.objects.get_or_create(user=u)[0])

If you created a user prior to setting up authentication on your app, you need to create a new super user on the terminal and then login with that account. I am certain there is no profile created as stated by the error!

Had the same error.
Adding the following code in models.py of the apps solved the problem.

def create_profile(sender, instance, created, *args, **kwargs):
    if not created:      # if user already exits then ignore
        return
    UserProfile.objects.create(user=instance)
post_save.connect(create_profile, sender=User)