Create new auth app; move user profiles, sign up and other authentication stuff there

Author: MaKleSoft

auth/__init__.py

@@ -0,0 +1,4 @@
+import auth.models
+from django.contrib import admin
+
+admin.site.register(auth.models.Profile)

auth/admin.py

@@ -0,0 +1,175 @@
+from auth.forms import SignUpForm
+import sha
+import datetime
+from random import random
+import pytz
+from django.contrib.auth import authenticate
+from django.contrib.auth.models import User
+from django.core.mail import send_mail
+from tastypie.serializers import Serializer
+from tastypie.utils.mime import determine_format
+from django.utils.translation import ugettext as _
+from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseNotFound
+from tastypie.resources import ModelResource, ALL_WITH_RELATIONS
+from tastypie import fields
+from auth.models import Profile
+from tastypie.authorization import DjangoAuthorization, Authorization
+from tastypie.authentication import Authentication, ApiKeyAuthentication
+
+
+class UserResource(ModelResource):
+
+    class Meta:
+        queryset = User.objects.all()
+        excludes = ['email', 'password']
+
+
+class ProfileResource(ModelResource):
+    user = fields.OneToOneField(UserResource, 'user')
+
+    class Meta:
+        queryset = Profile.objects.all()
+        authorization = Authorization()
+        authentication = Authentication()
+        excludes = ['activation_key', 'key_expires']
+        filtering = {
+            'user': ALL_WITH_RELATIONS,
+            'first_name': ['exact'],
+            'last_name': ['exact']
+        }
+
+    def dehydrate(self, bundle):
+        bundle.data['display_name'] = str(bundle.obj)
+
+
+def sign_up(request):
+    form = SignUpForm(request.POST)
+    serializer = Serializer()
+    format = determine_format(request, serializer,
+        default_format='application/json')
+
+    if form.is_valid():
+        username = form.cleaned_data['username']
+        password = form.cleaned_data['password']
+        email = form.cleaned_data['email']
+        first_name = form.cleaned_data['first_name']
+        last_name = form.cleaned_data['last_name']
+
+        user = User.objects.create(username=username, password=password,
+            first_name=first_name, last_name=last_name, email=email,
+            is_active=False)
+        user.save()
+
+        auth_profile = user.get_profile()
+
+        # Build the activation key
+        salt = sha.new(str(random())).hexdigest()[:5]
+        activation_key = sha.new(salt + user.username).hexdigest()
+        key_expires = datetime.datetime.now(pytz.utc) + datetime.timedelta(2)
+
+        # User is unactive until visiting activation link
+        auth_profile.activation_key = activation_key
+        auth_profile.key_expires = key_expires
+        activation_link = 'http://127.0.0.1:8000/auth/activate/' + activation_key
+
+        auth_profile.save()
+
+        subject = _('Welcome to ScoreIt!')
+        message = _('To activate, please click the following link:\n' + activation_link)
+        sender = _('noreply@score-it.de')
+        recipients = [email]
+        send_mail(subject, message, sender, recipients)
+
+        user_resource = UserResource()
+        profile_resource = ProfileResource()
+
+        data = {
+            'user': user_resource.get_resource_uri(user),
+            'profile': profile_resource.get_resource_uri(auth_profile),
+            'activation_key': activation_key
+        }
+
+        return HttpResponse(serializer.serialize(data, format, {}))
+
+    else:
+        return HttpResponseBadRequest(serializer.serialize(form.errors, format, {}))
+
+
+def validate_user(request):
+    """
+    Checks a user's basic auth credentials and, if valid, returns the users data
+    """
+
+    # if not request.META.get('HTTP_AUTHORIZATION'):
+    #     return HttpResponseBadRequest('No HTTP_AUTHORIZATION header found')
+
+    # try:
+    #     (auth_type, data) = request.META['HTTP_AUTHORIZATION'].split()
+    #     if auth_type.lower() != 'basic':
+    #         return HttpResponseBadRequest('Wrong auth type. Use basic auth!')
+    #     user_pass = base64.b64decode(data)
+    # except:
+    #     return HttpResponseBadRequest('Could not decode auth credentials.')
+
+    # bits = user_pass.split(':', 1)
+
+    # if len(bits) != 2:
+    #     return HttpResponseBadRequest('Could not decode auth credentials.')
+
+    # user = authenticate(username=bits[0], password=bits[1])
+
+    username = request.POST['username']
+    password = request.POST['password']
+
+    if not username or not password:
+        return HttpResponseBadRequest()
+
+    user = authenticate(username=username, password=password)
+
+    if user is None or not user.is_active:
+        return HttpResponseNotFound('User does not exist or password incorrect.')
+
+    auth_profile = user.get_profile()
+
+    profile_resource = ProfileResource()
+    bundle = profile_resource.build_bundle(obj=auth_profile, request=request)
+    profile_resource.full_dehydrate(bundle)
+    bundle.data['api_key'] = user.api_key.key
+
+    return HttpResponse(profile_resource.serialize(None, bundle, 'application/json'))
+
+
+def is_unique(request):
+    data = {}
+
+    if 'username' in request.GET:
+        username = request.GET['username']
+
+        try:
+            User.objects.get(username=username)
+            unique = False
+        except User.DoesNotExist:
+            unique = True
+        except User.MultipleObjectsReturned:
+            unique = False
+
+        data['username'] = unique
+
+    if 'email' in request.GET:
+        email = request.GET['email']
+
+        try:
+            User.objects.get(email=email)
+            unique = False
+        except User.DoesNotExist:
+            unique = True
+        except User.MultipleObjectsReturned:
+            unique = False
+
+        data['email'] = unique
+
+    serializer = Serializer()
+
+    format = determine_format(request, serializer, default_format='application/json')
+
+    return HttpResponse(serializer.serialize(data, format, {}))

auth/api.py

@@ -0,0 +1,32 @@
+from django import forms
+from django.utils.translation import ugettext as _
+from django.contrib.auth.models import User
+
+
+class SignUpForm(forms.Form):
+    username = forms.CharField(label=_('User name'), required=True)
+    email = forms.EmailField(label=_('Email'), required=True)
+    password = forms.CharField(widget=forms.PasswordInput,
+        label=_('Password'), required=True)
+    # password_repeat = forms.CharField(widget=forms.PasswordInput,
+    #     label=_('Repeat Password'), required=True)
+
+    first_name = forms.CharField(label=_('First Name'), required=True)
+    last_name = forms.CharField(label=_('Last Name'), required=True)
+
+    def clean_username(self):
+        data = self.cleaned_data['username']
+        try:
+            User.objects.get(username=data)
+        except User.DoesNotExist:
+            return data
+        raise forms.ValidationError(_('This username is already taken.'))
+
+    def clean_email(self):
+        data = self.cleaned_data['email']
+        try:
+            User.objects.get(email=data)
+        except User.DoesNotExist:
+            return data
+        raise forms.ValidationError(
+            _('A user with this email is already registered.'))

auth/forms.py

@@ -0,0 +1,22 @@
+from django.db import models
+from django.contrib.auth.models import User
+from django.db.models.signals import post_save
+
+
+class Profile(models.Model):
+    user = models.OneToOneField(User)
+
+    # Fields used for user activation after signup
+    activation_key = models.CharField(max_length=40, blank=True)
+    key_expires = models.DateTimeField(null=True, blank=True)
+
+    def __unicode__(self):
+        return '%s %s (%s)' % (self.user.first_name, self.user.last_name, self.user.username)
+
+
+def create_user_profile(sender, instance, created, **kwargs):
+    # Create user profile for user after creation
+    if created:
+        Profile.objects.create(user=instance)
+
+post_save.connect(create_user_profile, sender=User)

auth/models.py

@@ -0,0 +1,16 @@
+"""
+This file demonstrates writing tests using the unittest module. These will pass
+when you run "manage.py test".
+
+Replace this with more appropriate tests for your application.
+"""
+
+from django.test import TestCase
+
+
+class SimpleTest(TestCase):
+    def test_basic_addition(self):
+        """
+        Tests that 1 + 1 always equals 2.
+        """
+        self.assertEqual(1 + 1, 2)

auth/tests.py

@@ -0,0 +1,21 @@
+from django.conf.urls.defaults import *
+from tastypie.api import Api
+from auth.api import *
+
+
+v1_api = Api(api_name='v1')
+v1_api.register(UserResource())
+v1_api.register(ProfileResource())
+
+urlpatterns = patterns('auth.views',
+    (r'^activate/([abcdef0123456789]+)$', 'activate')
+)
+
+urlpatterns += patterns('', (r'^api/', include(v1_api.urls)))
+
+# Non-resource api endpoints
+urlpatterns += patterns('auth.api',
+    (r'^api/v1/validate/$', 'validate_user'),
+    (r'^api/v1/unique/$', 'is_unique'),
+    (r'^api/v1/signup/$', 'sign_up')
+)

auth/urls.py

@@ -0,0 +1,17 @@
+import datetime
+import pytz
+from django.shortcuts import get_object_or_404, render_to_response
+from auth.models import Profile
+
+
+def activate(request, activation_key):
+    auth_profile = get_object_or_404(Profile, activation_key=activation_key)
+    user = auth_profile.user
+
+    if auth_profile.key_expires < datetime.datetime.now(pytz.utc):
+        user.delete()
+        return render_to_response('activate.html', {'expired': True})
+
+    user.is_active = True
+    user.save()
+    return render_to_response('activate.html', {'success': True})

auth/views.py

@@ -120,10 +120,11 @@
     'tastypie',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
+    'auth',
     'handball'
 )
 
-AUTH_PROFILE_MODULE = 'handball.Person'
+AUTH_PROFILE_MODULE = 'auth.profile'
 
 EMAIL_HOST = 'wp253.webpack.hosteurope.de'
 

handball

@@ -5,6 +5,7 @@
 admin.autodiscover()
 
 urlpatterns = patterns('',
-    (r'^', include('handball.urls')),
+    (r'^auth/', include('auth.urls')),
+    (r'^handball/', include('handball.urls')),
     (r'^admin/', include(admin.site.urls))
 )