如何判断django用户是否曾经登录过？

Question

We have a Django project where a User account is created for a person whenever she calls us on the phone. The person may or may not, at a later point, use her account to log in to our website.

Question: How can I tell if a User has ever logged in to our website?

Clarification: I want to answer the question above for hundreds of existing users, not just for new users that are created from this point on.

Thought 1: Check User.last_login . Unfortunately Django initializes last_login to datetime.datetime.now() when the User is created, regardless of whether she ever logged in.

Thought 2: Check if User.last_login matches User.date_joined . Unfortunately Django initializes both these fields to datetime.now() , and they can be a few microseconds apart:

In [1]: u = User.objects.create(username="bla")

In [2]: u.date_joined - u.last_login
Out[2]: datetime.timedelta(0, 0, 23)

Current hack I am using: Assume the user has logged in at least once iff user.last_login - user.date_joined >= datetime.timedelta(seconds=1) .

Is there a better way to tell if a User has ever logged in?

Answer 1

If newer versions of Django (> 1.8), you should use User.last_login. This is what the documentation states:

last_login

A datetime of the user's last login.

Changed in Django 1.8: This field will be null if the user has never logged in. Previously it was set to the current date/time by default.

Answer 2

I'm going to assume that you're right when you say that both the date_joined and last_login are set to the current date on creation, and that for some reason there is enough time elapsed between the two assignments to create a noticeable delta.

If that's the case, then you could take @LAK's advice and create either a pre_save (and check if the instance's ID is 0) or post_save (and check the created parameter) and manually set the last_login field to either None or the same value as date_joined . From there all of your future data is preserved from the one-second fuzziness you seem to despise.

As for your existing data, I think that you're stuck making the best guess with the data you've got. I don't see it as too risky to make the assumption that you're making. If you wanted to clean it up to be the same as all new data, you could just update your database to set the last_login value. If you're using South , this is easy enough to do with a data migration. Otherwise, you could just create a script to run after you deploy the new code changes.

I honestly don't think that it's a problem that they're off by a little bit. So long as you're making the assumption that it's most likely not humanly possible for a user to log in within the time frame that their account was created, there seems to be little reason to add a bunch of extra work to force it to be an exact match.

Answer 3

I would use an F object to compare last_login with date_joined . If they're equal, then the user has never logged in (or at least never logged in after their initial signup, which is about the best you can determine)

from django.db.models import F

User.objects.filter(last_login=F('date_joined'))

UPDATE

Well, it successfully worked in my environment, but I suppose it is possible the two could be off by a few microseconds or more. If that's the case, then I think your only recourse is to actually manually check each User . You can do variations on the following if you need greater accuracy, but generally, I think a user who has never logged in after the day they initially created the count could be counted as "never logged in" for all intents and purposes -- either way, they've abandoned the account.

if user.date_joined.date() == user.last_login.date():
    # do something

If you need greater accuracy:

date_joined = datetime.combine(user.date_joined.date(), time(user.date_joined.hour, user.date_joined.minute))
last_login = datetime.combine(user.last_login.date(), time(user.last_login.hour, user.last_login.minute))
if date_joined == last_login:
    # do something

That essentially creates new datetime objects, removing the differences on seconds and microseconds. Surely a 1 minute accuracy level is good enough here.

Answer 4

Here is a solution that can filter a QuerySet by users that either has or hasn't logged on the site.

The filter_user_has_used_site() and filter_user_hasnt_used_site() functions works on a QuerySet containing auth.User .

The filter_resource_has_used_site() and filter_resource_hasnt_used_site() works on any queryset which model has a ForeignKey field named user to auth.User .

It only works for mysql but can easily be made to support other database engines.

from datetime import timedelta
from django.db import connection

MYSQL = "ABS(TIMESTAMPDIFF(SECOND,auth_user.last_login,auth_user.date_joined))"


def filter_resource_has_used_site(qs):
    """
    Takes a QuerySet of resources and returns a QuerySet only containing
    resources that has logged in to site at least once.
    """
    vendor = connection.vendor
    if vendor == 'mysql':
        # Force the orm to join to auth_user.
        qs = qs.filter(user__username__isnull=False)
        where = "".join([MYSQL, '>1'])
        return qs.extra(where=[where])
    else:
        raise NotImplementedError('Vendor type {} not supported.'.format(
            vendor))


def filter_resource_hasnt_used_site(qs):
    """
    Takes a QuerySet of resources and returns a QuerySet only containing
    resources that never logged in to site.
    """
    vendor = connection.vendor
    if vendor == 'mysql':
        # Force the orm to join to auth_user.
        qs = qs.filter(user__username__isnull=False)
        where = "".join([MYSQL, '<2'])
        return qs.extra(where=[where])
    else:
        raise NotImplementedError('Vendor type {} not supported.'.format(
            vendor))


def filter_user_has_used_site(qs):
    """
    Takes a QuerySet of users and returns a QuerySet only containing
    users that has logged in to site at least once.
    """
    vendor = connection.vendor
    if vendor == 'mysql':
        where = "".join([MYSQL, '>1'])
        return qs.extra(where=[where])
    else:
        raise NotImplementedError('Vendor type {} not supported.'.format(
            vendor))


def filter_user_hasnt_used_site(qs):
    """
    Takes a QuerySet of users and returns a QuerySet only containing
    users that never logged in to site.
    """
    vendor = connection.vendor
    if vendor == 'mysql':
        where = "".join([MYSQL, '<2'])
        return qs.extra(where=[where])
    else:
        raise NotImplementedError('Vendor type {} not supported.'.format(
            vendor))


def user_has_used_site(user):
    """
    Returns if a auth.user has logged into the site.
    """
    return abs(user.last_login - user.date_joined) > timedelta(seconds=1)