david / django-invitation-backend / changeset / b2977a099938

Up to file-list invitation/models.py:

@@ -14,21 +14,28 @@ from django.contrib.sites.models import
 from registration.models import SHA1_RE
 class InvitationKeyManager(models.Manager):
     def get_key(self, invitation_key):
         """
         Return InvitationKey, or None if it doesn't (or shouldn't) exist.
         """
         # Don't bother hitting database if invitation_key doesn't match pattern.
         if not SHA1_RE.search(invitation_key):
             return None
         try:
             key = self.get(key=invitation_key)
         except self.model.DoesNotExist:
             return None
         return key
     def is_key_valid(self, invitation_key):
         """
         Check if an ``InvitationKey`` is valid or not, returning a boolean,
         ``True`` if the key is valid.
         """
         # Make sure the key we're trying conforms to the pattern of a
         # SHA1 hash; if it doesn't, no point trying to look it up in
         # the database.
         if SHA1_RE.search(invitation_key):
             try:
                 invitation_key = self.get(key=invitation_key)
             except self.model.DoesNotExist:
                 return False
             return not invitation_key.key_expired()
         return False
         invitation_key = self.get_key(invitation_key)
         return invitation_key and invitation_key.is_usable()
     def create_invitation(self, user):
         """
@@ -58,13 +65,22 @@ class InvitationKey(models.Model):
     key = models.CharField(_('invitation key'), max_length=40)
     date_invited = models.DateTimeField(_('date invited'),
                                         default=datetime.datetime.now)
-    from_user = models.ForeignKey(User)
+    from_user = models.ForeignKey(User,
                                   related_name='invitations_sent')
     registrant = models.ForeignKey(User, null=True, blank=True,
                                   related_name='invitations_used')
     objects = InvitationKeyManager()
     def __unicode__(self):
         return u"Invitation from %s on %s" % (self.from_user.username, self.date_invited)
     def is_usable(self):
         """
         Return whether this key is still valid for registering a new user.
         """
         return self.registrant is None and not self.key_expired()
     def key_expired(self):
         """
         Determine whether this ``InvitationKey`` has expired, returning
@@ -81,6 +97,13 @@ class InvitationKey(models.Model):
         return self.date_invited + expiration_date <= datetime.datetime.now()
     key_expired.boolean = True
     def mark_used(self, registrant):
         """
         Note that this key has been used to register a new user.
         """
         self.registrant = registrant
         self.save()
     def send_to(self, email):
         """
         Send an invitation email to ``email``.

Up to file-list invitation/tests.py:

@@ -217,7 +217,9 @@ class InvitationViewTests(InvitationTest
         redirect_location = response._headers['location'][1]
         self.assertTrue(redirect_location.endswith(
                         reverse('registration_complete')))
-        user = User.objects.get(username='new_user')
+        user = User.objects.get(username='new_user')
         key = InvitationKey.objects.get_key(self.sample_key.key)
         self.assertEqual(user, key.registrant)
         # Trying to reuse the same key then fails.
         registration_data['username'] = 'even_newer_user'

Up to file-list invitation/views.py:

@@ -15,6 +15,24 @@ remaining_invitations_for_user = Invitat
 # TODO: move the authorization control to a dedicated decorator
 class InvitationUsedCallback(object):
     """
     Callable to mark InvitationKey as used, by way of profile_callback.
     """
     def __init__(self, invitation_key, profile_callback):
         self.invitation_key = invitation_key
         self.profile_callback = profile_callback
     def __call__(self, user):
         """Mark the key used, and then call the real callback (if any)."""
         key = InvitationKey.objects.get_key(self.invitation_key)
         if key:
             key.mark_used(user)
         if self.profile_callback:
             self.profile_callback(user)
 def invited(request, invitation_key=None, extra_context=None):
     if 'INVITE_MODE' in settings.get_all_members() and settings.INVITE_MODE:
         if invitation_key and is_key_valid(invitation_key):
@@ -37,6 +55,8 @@ def register(request, success_url=None,
             if is_key_valid(request.REQUEST['invitation_key']):
                 invitation_key = request.REQUEST['invitation_key']
                 extra_context.update({'invitation_key': invitation_key})
                 profile_callback = InvitationUsedCallback(invitation_key,
                                                           profile_callback)
                 return registration_register(request, success_url, form_class,
                             profile_callback, template_name, extra_context)
             else:

commit 21:	b2977a099938
parent 20:	e5a394941120
branch:	default

david / django-invitation-backend (http://code.welldev.org/django-invitation/)