django-tos 0.8.0

Advantages

• Can optionally use a separate cache for TOS agreements (necessary if your default cache does not support atomic increment operations)

• Allow some of your users to skip the TOS check (eg: developers, staff, admin, superusers, employees)

• Uses signals to invalidate cached agreements

• Skips the agreement check when the user is anonymous or not signed in

• Skips the agreement check when the request is AJAX

• Skips the agreement check when the request isn’t a GET request (to avoid getting in the way of data mutations)

Disadvantages

• Requires a cache key for each user who is signed in

• Requires an additional cache key for each staff user

• May leave keys in the cache when the active TermsOfService changes

Efficiency

• Best case for staff users: 2 cache hits

• Best case for non-staff users: 1 cache miss, 2 cache hits

• Worst case: 1 cache hit, 2 cache misses, 1 database query, 1 cache set (this should only happen when the user signs in)

Option 2 Configuration

1. In your root urlconf file urls.py only add the terms-of-service URLs:

   # terms of service links
   urlpatterns += patterns('',
       url(r'^terms-of-service/', include('tos.urls')),
   )

2. Optional: Since the cache used by TOS will be overwhelmingly read-heavy, you can use a separate cache specifically for TOS. To do so, create a new cache in your project’s settings.py:

   CACHES = {
       ...
       # The cache specifically for django-tos
       'tos': {  # Can use any name here
           'BACKEND': ...,
           'LOCATION': ...,
           'NAME': 'tos-cache',  # Can use any name here
       },
   }

   and configure django-tos to use the new cache:

   TOS_CACHE_NAME = 'tos'  # Must match the key name in in CACHES

   this setting defaults to the default cache.

4. Then in your project’s settings.py add the middleware to MIDDLEWARE_CLASSES:

   MIDDLEWARE_CLASSES = (
       ...
       # Terms of service checks
       'tos.middleware.UserAgreementMiddleware',
   )

5. Optional: To allow users to skip the TOS check, you will need to set corresponding cache keys for them in the TOS cache. The cache key for each user will need to be prefixed with django:tos:skip_tos_check:, and have the user ID appended to it.

   Here is an example app configuration that allows staff users and superusers to skip the TOS agreement check:

   from django.apps import AppConfig, apps
   from django.conf import settings
   from django.contrib.auth import get_user_model
   from django.core.cache import caches
   from django.db.models import Q
   from django.db.models.signals import post_save, pre_save
   from django.dispatch import receiver
   
   class MyAppConfig(AppConfig):
       name = 'myapp'
   
       def ready(self):
           if 'tos' in settings.INSTALLED_APPS:
               cache = caches[getattr(settings, 'TOS_CACHE_NAME', 'default')]
               tos_app = apps.get_app_config('tos')
               TermsOfService = tos_app.get_model('TermsOfService')
   
               @receiver(post_save, sender=get_user_model(), dispatch_uid='set_staff_in_cache_for_tos')
               def set_staff_in_cache_for_tos(user, instance, **kwargs):
                   if kwargs.get('raw', False):
                       return
   
                   # Get the cache prefix
                   key_version = cache.get('django:tos:key_version')
   
                   # If the user is staff allow them to skip the TOS agreement check
                   if instance.is_staff or instance.is_superuser:
                       cache.set('django:tos:skip_tos_check:{}'.format(instance.id), version=key_version)
   
                   # But if they aren't make sure we invalidate them from the cache
                   elif cache.get('django:tos:skip_tos_check:{}'.format(instance.id), False):
                       cache.delete('django:tos:skip_tos_check:{}'.format(instance.id), version=key_version)
   
               @receiver(post_save, sender=TermsOfService, dispatch_uid='add_staff_users_to_tos_cache')
               def add_staff_users_to_tos_cache(*args, **kwargs):
                   if kwargs.get('raw', False):
                       return
   
                   # Get the cache prefix
                   key_version = cache.get('django:tos:key_version')
   
                   # Efficiently cache all of the users who are allowed to skip the TOS
                   # agreement check
                   cache.set_many({
                       'django:tos:skip_tos_check:{}'.format(staff_user.id): True
                       for staff_user in get_user_model().objects.filter(
                           Q(is_staff=True) | Q(is_superuser=True))
                   }, version=key_version)
   
               # Immediately add staff users to the cache
               add_staff_users_to_tos_cache()