Initial commit

Author: ferranp

.hgignore

@@ -0,0 +1,8 @@
+# use glob syntax.
+syntax: glob
+*.pyc
+dev.db
+htmlcov
+.coverage
+dist
+MANIFEST

AUTHORS

@@ -0,0 +1 @@
+Ferran Pegueroles

README.rst

@@ -0,0 +1,71 @@
+================
+django-last-seen
+================
+
+Keep trak of when a user has been last seen on a website.
+The last seen time is kept on the database
+
+The app is ready for django 1.5, it uses the AUTH_USER_MODEL setting to get
+the user model,
+
+Installation
+============
+
+#. Install with ``pip install django-last-seen"`` or add ``"last_seen"``
+   directory to your Python path.
+#. Add ``"last_seen"`` to the ``INSTALLED_APPS`` tuple found in your settings
+   file.
+#. Add 'last_seen.middleware.LastSeenMiddleWare' to MIDDLEWARE_CLASSES tuple
+   found in your settings file.
+#. Run ``manage.py syncdb`` to create the new tables
+
+Usage
+=====
+
+To get when a user has been last seen::
+
+    from last_seen.model import LastSeen
+
+    seen = LastSeen.object.when(user=user)
+
+
+To save a last seen user without the middleware::
+
+    from last_seen.model import LastSeen
+
+    # save with a special module
+    LastSeen.object.when(user=user, module='forum')
+
+Middleware
+==========
+
+The provided middleware keeps track of when an authenticated user has been
+last seen on the site,
+
+If you want to keep track of a user last seen on a part of a site, you can
+use a special module name and use::
+
+    from last_seen.model import LastSeen
+
+    # save with a special module
+    LastSeen.object.when(user=user, module='forum')
+
+Then to get the data::
+
+    from last_seen.model import LastSeen
+
+    # user last seen on any part of the site
+    seen = LastSeen.object.when(user=user)
+
+    # user last seen on a module
+    seen = LastSeen.object.when(user=user, module='forum')
+
+Settings
+========
+
+:LAST_SEEN_DEFAULT_MODULE: The default module used on the middleware. The
+default value is ``default``.
+
+:LAST_SEEN_INTERVAL: How often is the last seen timestamp updated to the
+database. The default is 2 hours.
+

last_seen/__init__.py

@@ -0,0 +1,13 @@
+
+from django.contrib import admin
+
+from models import LastSeen
+
+
+class LastSeenAdmin(admin.ModelAdmin):
+    list_filter = ('site', 'module', 'last_seen')
+    search_fields = ('user__username',)
+    list_display = ('site', 'module', 'user', 'last_seen')
+
+
+admin.site.register(LastSeen, LastSeenAdmin)

last_seen/admin.py

@@ -0,0 +1,12 @@
+
+
+from models import user_seen
+
+
+class LastSeenMiddleWare(object):
+
+    def process_request(request):
+        if request.user.is_autheticated():
+            user_seen(request.user)
+
+        return None

last_seen/middleware.py

@@ -0,0 +1,54 @@
+import time
+from django.db import models
+from django.contrib.sites.models import Site
+from django.utils import timezone
+from django.core.cache import cache
+
+import settings
+
+
+class LastSeenManager(models.Manager):
+    def seen(self, user, module=settings.LAST_SEEN_DEFAULT_MODULE):
+        args = {
+            'user': user,
+            'site': Site.objects.get_current(),
+            'module': module,
+        }
+        updated = self.filter(**args).update(last_seen=timezone.now())
+        if not updated:
+            self.create(**args)
+
+    def when(self, user, module=None, site=None):
+        args = {'user': user}
+        if module:
+            args['module'] = module
+        if site:
+            args['site'] = site
+        return self.filter(**args).latest('last_seen').last_seen
+
+
+class LastSeen(models.Model):
+    site = models.ForeignKey(Site)
+    user = models.ForeignKey(settings.AUTH_USER_MODEL)
+    module = models.CharField(default=settings.LAST_SEEN_DEFAULT_MODULE, max_length=20)
+    last_seen = models.DateTimeField(default=timezone.now)
+
+    objects = LastSeenManager()
+
+    class Meta:
+        unique_together = (('user', 'site', 'module'),)
+        ordering = ('-last_seen',)
+
+    def __unicode__(self):
+        return u"%s on %s" % (self.user, self.last_seen)
+
+
+def user_seen(user, module=settings.LAST_SEEN_DEFAULT_MODULE):
+    # compute limit to update db
+    cache_key = "last_seen:%s:%s" % (module, user.pk)
+    limit = time.time() - settings.LAST_SEEN_INTERVAL
+    seen = cache.get(cache_key)
+    if not seen or seen < limit:
+        # mark the database and the cache
+        LastSeen.objects.seen(user, module=module)
+        cache.set(cache_key, time.time())

last_seen/models.py

@@ -0,0 +1,8 @@
+from django.conf import settings
+
+
+LAST_SEEN_DEFAULT_MODULE = getattr(settings, 'LAST_SEEN_DEFAULT_MODULE',
+                                   'default')
+LAST_SEEN_INTERVAL = getattr(settings, 'LAST_SEEN_INTERVAL', 60 * 60 * 2)
+
+AUTH_USER_MODEL = getattr(settings, 'AUTH_USER_MODEL', 'auth.User')

last_seen/settings.py

@@ -0,0 +1,108 @@
+import datetime
+import mock
+import time
+from django.test import TestCase
+from django.utils import timezone
+from django.contrib.auth.models import User
+from django.contrib.sites.models import Site
+from django.core.cache import cache
+
+from last_seen.models import LastSeen, user_seen
+from last_seen import settings
+from last_seen import middleware
+
+
+class TestLastSeenModel(TestCase):
+
+    def test_unicode(self):
+        user = User(username='testuser')
+        ts = datetime.datetime(2013, 1, 1, 2, 3, 4)
+        seen = LastSeen(user=user, last_seen=ts)
+        self.assertIn('testuser', unicode(seen))
+        self.assertIn('2013-01-01 02:03:04', unicode(seen))
+
+
+class TestLastSeenManager(TestCase):
+
+    @mock.patch('last_seen.models.LastSeen.objects.create')
+    @mock.patch('last_seen.models.LastSeen.objects.filter')
+    def test_seen(self, filter, create):
+        user = User(username='testuser')
+        filter.return_value.update.return_value = 1
+
+        LastSeen.objects.seen(user=user)
+
+        filter.assert_called_with(user=user,
+                module=settings.LAST_SEEN_DEFAULT_MODULE,
+                site=Site.objects.get_current())
+        self.assertFalse(create.called)
+
+    @mock.patch('last_seen.models.LastSeen.objects.create')
+    @mock.patch('last_seen.models.LastSeen.objects.filter')
+    def test_seen_create(self, filter, create):
+        user = User(username='testuser')
+        filter.return_value.update.return_value = 0
+
+        LastSeen.objects.seen(user=user)
+
+        filter.assert_called_with(user=user,
+                module=settings.LAST_SEEN_DEFAULT_MODULE,
+                site=Site.objects.get_current())
+        create.assert_called_with(user=user,
+                module=settings.LAST_SEEN_DEFAULT_MODULE,
+                site=Site.objects.get_current())
+
+    def test_when_non_existent(self):
+        user = User(username='testuser', pk=1)
+        self.assertRaises(LastSeen.DoesNotExist, LastSeen.objects.when, user)
+
+    @mock.patch('last_seen.models.LastSeen.objects.filter')
+    def test_seen_defaults(self, filter):
+        user = User(username='testuser')
+        LastSeen.objects.when(user=user)
+
+        filter.assert_called_with(user=user)
+
+    @mock.patch('last_seen.models.LastSeen.objects.filter')
+    def test_seen_module(self, filter):
+        user = User(username='testuser')
+        LastSeen.objects.when(user=user, module='mod')
+
+        filter.assert_called_with(user=user, module='mod')
+
+    @mock.patch('last_seen.models.LastSeen.objects.filter')
+    def test_seen_site(self, filter):
+        user = User(username='testuser')
+        site = Site()
+        LastSeen.objects.when(user=user, site=site)
+
+        filter.assert_called_with(user=user, site=site)
+
+
+class TestUserSeen(TestCase):
+
+    @mock.patch('last_seen.models.LastSeen.objects.seen')
+    def test_user_seen(self, seen):
+        user = User(username='testuser', pk=1)
+        user_seen(user)
+        seen.assert_called_with(user, module=settings.LAST_SEEN_DEFAULT_MODULE)
+
+    @mock.patch('last_seen.models.LastSeen.objects.seen')
+    def test_user_seen_cached(self, seen):
+        user = User(username='testuser', pk=1)
+        module = 'test_mod'
+        cache.set("last_seen:%s:%s" % (module, user.pk), time.time())
+        user_seen(user, module=module)
+        self.assertFalse(seen.called)
+
+    @mock.patch('last_seen.models.LastSeen.objects.seen')
+    def test_user_seen_cache_expired(self, seen):
+        user = User(username='testuser', pk=1)
+        module = 'test_mod'
+        cache.set("last_seen:%s:%s" % (module, user.pk),
+                time.time() - (2 * settings.LAST_SEEN_INTERVAL))
+        user_seen(user, module=module)
+        seen.assert_called_with(user, module=module)
+
+class TestMiddleWare(TestCase):
+    pass

last_seen/tests.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+import os
+import sys
+
+if __name__ == "__main__":
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "test_project.settings")
+
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)

manage.py

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+MODULES=${1:-last_seen}
+
+coverage run --branch ./manage.py test $MODULES || exit 2
+coverage report --include="./last_seen/*" --omit="./*/migrations/*"
+coverage html --include="./last_seen/*" --omit="./*/migrations/*"

runtests.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+from distutils.core import setup
+
+__author__ = u'Ferran Pegueroles'
+__copyright__ = u'Copyright 2013, Ferran Pegueroles'
+__credits__ = [u'Ferran Pegueroles']
+
+
+__license__ = 'GPL'
+__version__ = '0.1'
+__email__ = '[email protected]'
+
+
+long_description = open('README.rst').read()
+
+
+setup(
+    name='django-last-seen',
+    version=__version__,
+    url='http://bitbucket.org/ferranp/django-last-seen',
+    author=__author__,
+    author_email=__email__,
+    license='GPL',
+    packages=['last_seen'],
+    description='Keep track of when a user has been last seen',
+    long_description=long_description,
+    classifiers=['Development Status :: 5 - Production/Stable',
+                 'Environment :: Web Environment',
+                 'Framework :: Django',
+                 'Intended Audience :: Developers',
+                 'License :: OSI Approved :: GNU General Public License (GPL)',
+                 'Topic :: Internet :: WWW/HTTP :: Dynamic Content']
+)

setup.py

@@ -0,0 +1,34 @@
+# Django settings for test_project project.
+
+DEBUG = True
+TEMPLATE_DEBUG = DEBUG
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
+        'NAME': ':memory:',                      # Or path to database file if using sqlite3.
+        'USER': '',                      # Not used with sqlite3.
+        'PASSWORD': '',                  # Not used with sqlite3.
+        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
+        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
+    }
+}
+
+SITE_ID = 1
+
+ROOT_URLCONF = 'test_project.urls'
+
+INSTALLED_APPS = (
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.sites',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    # Uncomment the next line to enable the admin:
+    'django.contrib.admin',
+    # Uncomment the next line to enable admin documentation:
+    # 'django.contrib.admindocs',
+    'last_seen'
+)
+

test_project/__init__.py

@@ -0,0 +1,17 @@
+from django.conf.urls import patterns, include, url
+
+# Uncomment the next two lines to enable the admin:
+from django.contrib import admin
+admin.autodiscover()
+
+urlpatterns = patterns('',
+    # Examples:
+    # url(r'^$', 'test_project.views.home', name='home'),
+    # url(r'^test_project/', include('test_project.foo.urls')),
+
+    # Uncomment the admin/doc line below to enable admin documentation:
+    # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
+
+    # Uncomment the next line to enable the admin:
+    url(r'^admin/', include(admin.site.urls)),
+)