Django：自动从用户模型中捕获用户名。 不是pk

Question

I want to capture the username of the user currently logged in, NOT pk.

incident.username = request.user doesn't work

incident.username = request.user.username doesn't work

incident.username = request.username doesn't work

Uggg. This can't be this hard.

models.py

class Incident(models.Model):
    username = models.ForeignKey(User)      ## field in db will be auto-populated by view.py
    date_reported = models.DateField()      ## field in db will be auto-populated by view.py
    date_occurred = models.DateField()
    number_of_samples_affected = models.IntegerField()
    capa = models.CharField(max_length=9)
    title =  models.CharField(max_length=100)
    description = models.TextField()
    status = models.ForeignKey(Status)      ## field in db will be auto-populated by view.py to "Open" at form submission
    category = models.ForeignKey(Category)                                      
    lab = models.TextField(Lab)

views.py

from submit_app.forms import IncidentForm
from submit_app.models import Incident, Status
from django.shortcuts import render
from django.contrib.auth.decorators import login_required
import datetime
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse

@login_required(login_url='/login/')
def submit(request):

    if request.GET:
        form = IncidentForm()
        template = 'submit.html'
        context = {'form': form}
        return render(request, template, context)

    # if this is a POST request we need to process the form data
    if request.POST:

        # create a form instance and populate it with the data from the request:
        form = IncidentForm(request.POST)

        # check whether it's valid:
        if form.is_valid():
            incident = form.save(False)                         # creating an incident object, but not saving it to the db just yet
            incident.username = request.user                    # auto capture logged in user
            incident.date_reported = datetime.date.today()      # auto capture the incident submission date
            incident.status = Status.objects.get(status="open") # trying to auto populate status with 'Open' upon submission (foreign key)
            incident.save()
            return HttpResponseRedirect(reverse('dashboard_app:dashboard'))

    form = IncidentForm()
    template = 'submit.html'
    context = {'form': form}
    return render(request, template, context)

Answer 1

Right now, your model has a foreign key relation to the User model, which by default relates to the primary key field. To change that and relate to the username field itself, add a to_field keyword argument to your model, makemigrations , and migrate .

username = models.ForeignKey(User,to_field='username')  

Afterwards, you'll be able to access the user for the current request via request.user.username , assuming that username is a field/attribute of User (and not a related model).

...

However, there's generally no need to do this. You can still relate to the User model (relation built via PK) and access the username from there. Easiest way to do this is perhaps to create a method to read the username.

class Incident(models.Model):
    user = models.ForeignKey(User, related_name='incidents')
    def username(self):
        if self.user:
            return getattr(self.user,'username',None) # attempt to access username

... 

>>> first_incident = Incident.objects.create(user=User.objects.get(username='a'))
>>> print(first_incident.username())
a

Answer 2

There is some obvious confusion. Incident.username is a foreign key to a User model, so it needs to be assigned a User object, not just a username. For that incident.username = request.user should work. You can later access the user name by accessing incident.username.username , although I would rename the field to user to avoid confusion. If this doesn't work, something is not working as it should. It would help if you posted the error you are getting.

Answer 3

You should use custom user model and specify usename field to be primary key. But in django abstract base classes for models can't have "overriden fields" so you will need to sublcass AbstractBaseUser instead of AbstractUser . You may eventually end up with a copy of AbstractUser code ( https://github.com/django/django/blob/1.8.9/django/contrib/auth/models.py#L378 ) with just one line changed:

from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, validators, UserManager

class MyUser(AbstractBaseUser, PermissionsMixin):
    username = models.CharField(_('username'), max_length=30, unique=True,
        primary_key=True, ## the only difference from AbstractUser        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)

After this you will be able to point FK fields to username field. But do you realy need this? Why do you need to have such FK? Primary keys should better be "static". By using username as primary key you will have problems changing your usernames.

I can imagine several reasons for such a requirement:

1. You want your incidents to point specific username instead of actual user (maybe your instances of User may be deleted and later recreated with same username?). This is strange but can be done: use username = CharField(...) and also specify property for user with getter and setter.

    class Incident(models.Model): username = models.CharField(max_length=30) @property def user(self): return User.objects.get(username=self.username) @user.setter def user(self, user): if user.is_authenticated(): self.username = user.username else: self.username = '#anonymous' # by default '#' is disallowed in username. You can also make your username nullable 

2. you want to "optimize" database calls (to not query users table). In this case you'd better use prefetching or denormalization:

    from django.db import models # prefetch user with only "username" field. Assuming that you have `Incident.user = models.ForeignKey(...)`. Read https://docs.djangoproject.com/en/1.9/topics/db/managers/ and https://docs.djangoproject.com/en/1.9/ref/models/querysets/#prefetch-related class IncidentManager(models.Manager): def get_queryset(self): return super(IncidentManager, self).get_queryset().prefetch_related(models.Prefetch('user', queryset=User.objects.all().only('username')) class Incident(models.Model): user = models.ForeignKey(User) # ... objects = IncidentManager() 

   In case of denormalization you should create receiver for post_save and post_delete signals for User model which should update Incident.username field with actual username. You must also create similar signal receivers for Incident's post_save/post_delete (or you can modify Incident.save and Incident.delete methods). You may also create signal receiver for admin.models.LogAction post_save signal ( from django.contrib.admin.models import DELETEION; if instance.action_flag == DELETEION and instance.content_type_id=get_content_type_for_model(Incident).pk: ) because mass deletion from django-admin does not call Incident.delete and does not trigger post_delete for deleted incidnets. And even after this denormalized data may be invalid if you use User.object.update(username=something) anywhere in your project or if data is changed directly in database.