--- a/.hgignore	Sat May 05 15:08:07 2012 -0500
+++ b/.hgignore	Sat May 05 17:10:48 2012 -0500
@@ -13,6 +13,5 @@
 media/podcast
 media/potd
 media/smiley
-gpp/celerybeat-schedule
-gpp/xapian_index
-
+celerybeat-schedule
+sg101/xapian_index

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accounts/__init__.py	Sat May 05 17:10:48 2012 -0500
@@ -0,0 +1,37 @@
+import datetime
+import logging
+
+from django.contrib.auth.models import User
+
+
+def create_new_user(pending_user, ip=None, admin_activation=False):
+    """
+    This function contains the code to create a new user from a
+    pending user. The pending user is deleted and the new user
+    is saved. A log message is produced. If admin_activation is false,
+    then ip should be the user's IP they confirmed from, if available.
+
+    """
+    new_user = User()
+
+    new_user.username = pending_user.username
+    new_user.first_name = ''
+    new_user.last_name = ''
+    new_user.email = pending_user.email
+    new_user.password = pending_user.password     # already been hashed
+    new_user.is_staff = False
+    new_user.is_active = True
+    new_user.is_superuser = False
+    new_user.last_login = datetime.datetime.now()
+    new_user.date_joined = new_user.last_login
+
+    new_user.save()
+    pending_user.delete()
+
+    if admin_activation:
+        msg = 'Accounts registration confirmed by ADMIN for %s' % new_user.username
+    else:
+        msg = 'Accounts registration confirmed by USER for %s from %s' % (
+                new_user.username, ip)
+
+    logging.info(msg)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accounts/admin.py	Sat May 05 17:10:48 2012 -0500
@@ -0,0 +1,29 @@
+"""This file contains the automatic admin site definitions for the accounts Models"""
+
+from django.contrib import admin
+from accounts.models import IllegalUsername
+from accounts.models import IllegalEmail
+from accounts.models import PendingUser
+from accounts import create_new_user
+
+
+class PendingUserAdmin(admin.ModelAdmin):
+   list_display = ('username', 'email', 'date_joined')
+   actions = ('activate_account', )
+
+   def activate_account(self, request, qs):
+       """
+       Activate the accounts of the selected pending users.
+
+       """
+       for pending_user in qs:
+           create_new_user(pending_user, admin_activation=True)
+
+       self.message_user(request, "%s accounts activated" % qs.count())
+
+   activate_account.short_description = "Activate accounts for selected users"
+
+
+admin.site.register(IllegalUsername)
+admin.site.register(IllegalEmail)
+admin.site.register(PendingUser, PendingUserAdmin)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accounts/fixtures/accounts.json	Sat May 05 17:10:48 2012 -0500
@@ -0,0 +1,30 @@
+[
+    {
+        "pk": 1, 
+        "model": "accounts.illegalusername", 
+        "fields": {
+            "username": "root"
+        }
+    }, 
+    {
+        "pk": 2, 
+        "model": "accounts.illegalusername", 
+        "fields": {
+            "username": "sg101"
+        }
+    }, 
+    {
+        "pk": 3, 
+        "model": "accounts.illegalusername", 
+        "fields": {
+            "username": "surfguitar101"
+        }
+    }, 
+    {
+        "pk": 4, 
+        "model": "accounts.illegalusername", 
+        "fields": {
+            "username": "webmaster"
+        }
+    }
+]
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accounts/forms.py	Sat May 05 17:10:48 2012 -0500
@@ -0,0 +1,152 @@
+"""forms for the accounts application"""
+
+import logging
+
+from django import forms
+from django.contrib.auth.models import User
+from django.core.urlresolvers import reverse
+from django.template.loader import render_to_string
+from django.contrib.sites.models import Site
+from django.conf import settings
+
+from core.functions import send_mail
+from accounts.models import PendingUser
+from accounts.models import IllegalUsername
+from accounts.models import IllegalEmail
+from antispam.rate_limit import block_ip
+
+
+class RegisterForm(forms.Form):
+    """Form used to register with the website"""
+    username = forms.RegexField(
+            max_length=30,
+            regex=r'^\w+$',
+            error_messages={'invalid': ('Your username must be 30 characters or'
+                ' less and contain only letters, numbers and underscores.')},
+            widget=forms.TextInput(attrs={'class': 'text'}),
+            )
+    email = forms.EmailField(widget=forms.TextInput(attrs={'class': 'text'}))
+    password1 = forms.CharField(label="Password",
+            widget=forms.PasswordInput(attrs={'class': 'text'}))
+    password2 = forms.CharField(label="Password confirmation",
+            widget=forms.PasswordInput(attrs={'class': 'text'}))
+    agree_age = forms.BooleanField(required=True,
+        label='I certify that I am over the age of 13',
+        error_messages={
+            'required': 'Sorry, but you must be over the age of 13 to '
+                    'register at our site.',
+            })
+    agree_tos = forms.BooleanField(required=True,
+       label='I agree to the Terms of Service',
+        error_messages={
+            'required': 'You have not agreed to our Terms of Service.',
+            })
+    agree_privacy = forms.BooleanField(required=True,
+        label='I agree to the Privacy Policy',
+        error_messages={
+            'required': 'You have not agreed to our Privacy Policy.',
+            })
+    question1 = forms.CharField(label="What number appears in the site name?",
+        widget=forms.TextInput(attrs={'class': 'text'}))
+    question2 = forms.CharField(label='', required=False,
+        widget=forms.TextInput(attrs={'style': 'display: none;'}))
+
+    def __init__(self, *args, **kwargs):
+        self.ip = kwargs.pop('ip', '?')
+        super(RegisterForm, self).__init__(*args, **kwargs)
+
+    def clean_username(self):
+        username = self.cleaned_data['username']
+        try:
+            User.objects.get(username=username)
+        except User.DoesNotExist:
+            try:
+                PendingUser.objects.get(username=username)
+            except PendingUser.DoesNotExist:
+                try:
+                    IllegalUsername.objects.get(username=username)
+                except IllegalUsername.DoesNotExist:
+                    return username
+                self._validation_error("That username is not allowed.", username)
+            self._validation_error("A pending user with that username already exists.", username)
+        self._validation_error("A user with that username already exists.", username)
+
+    def clean_email(self):
+        email = self.cleaned_data['email']
+
+        if User.objects.filter(email=email).count():
+            self._validation_error("A user with that email address already exists.", email)
+        elif PendingUser.objects.filter(email=email).count():
+            self._validation_error("A pending user with that email address already exists.", email)
+        elif IllegalEmail.objects.filter(email=email).count():
+            self._validation_error("That email address is not allowed.", email)
+        
+        # email is ok
+        return email
+
+    def clean_password2(self):
+        password1 = self.cleaned_data.get("password1", "")
+        password2 = self.cleaned_data["password2"]
+        if password1 != password2:
+            self._validation_error("The two password fields didn't match.")
+        if len(password1) < 6:
+            self._validation_error("Please choose a password of 6 characters or more.")
+        return password2
+
+    def clean_question1(self):
+        answer = self.cleaned_data.get('question1')
+        success = False
+        if answer:
+            try:
+                val = int(answer)
+            except ValueError:
+                pass
+            else:
+                success = val == 101
+        if not success:
+            self._validation_error("Incorrect answer to our anti-spam question.", answer)
+        return answer
+
+    def clean_question2(self):
+        """
+        Honeypot field should be empty.
+        """
+        answer = self.cleaned_data.get('question2')
+        if answer:
+            block_ip(self.ip)
+            self._validation_error('Wrong answer #2: %s' % answer)
+        return answer
+
+    def save(self):
+        pending_user = PendingUser.objects.create_pending_user(self.cleaned_data['username'],
+                self.cleaned_data['email'],
+                self.cleaned_data['password1'])
+
+        # Send the confirmation email
+
+        site = Site.objects.get_current()
+        admin_email = settings.ADMINS[0][1]
+
+        activation_link = 'http://%s%s' % (site.domain, reverse('accounts.views.register_confirm',
+                kwargs = {'username' : pending_user.username, 'key' : pending_user.key}))
+
+        msg = render_to_string('accounts/registration_email.txt',
+                {
+                    'site_name' : site.name,
+                    'site_domain' : site.domain,
+                    'user_email' : pending_user.email,
+                    'activation_link' : activation_link,
+                    'username' : pending_user.username,
+                    'admin_email' : admin_email,
+                })
+
+        subject = 'Registration Confirmation for ' + site.name
+        send_mail(subject, msg, admin_email, [self.cleaned_data['email']])
+        logging.info('Accounts/registration conf. email sent to %s for user %s; IP = %s',
+                self.cleaned_data['email'], pending_user.username, self.ip)
+
+        return pending_user
+
+    def _validation_error(self, msg, param=None):
+        logging.error('Accounts/registration [%s]: %s (%s)', self.ip, msg, param)
+        raise forms.ValidationError(msg)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accounts/management/commands/rate_limit_clear.py	Sat May 05 17:10:48 2012 -0500
@@ -0,0 +1,54 @@
+"""
+The rate_limit_clear command is used to clear IP addresses out from our rate
+limit protection database.
+
+"""
+from optparse import make_option
+import re
+
+from django.core.management.base import BaseCommand
+import redis
+
+from core.services import get_redis_connection
+
+
+IP_RE = re.compile(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$')
+
+
+class Command(BaseCommand):
+    help = """Remove IP addresses from the rate limit protection datastore."""
+    option_list = list(BaseCommand.option_list) + [
+        make_option("--purge", action="store_true",
+            help="Purge all IP addresses"),
+    ]
+
+    def handle(self, *args, **kwargs):
+        try:
+            con = get_redis_connection()
+
+            # get all rate-limit keys
+            keys = con.keys('rate-limit-*')
+
+            # if purging, delete them all...
+            if kwargs['purge']:
+                if keys:
+                    con.delete(*keys)
+                return
+
+            # otherwise delete the ones the user asked for
+            ips = []
+            for ip in args:
+                if IP_RE.match(ip):
+                    key = 'rate-limit-%s' % ip
+                    if key in keys:
+                        ips.append(key)
+                    else:
+                        self.stdout.write('%s not found\n' % ip)
+                else:
+                    self.stderr.write('invalid IP address %s\n' % ip)
+
+            if ips:
+                con.delete(*ips)
+
+        except redis.RedisError, e:
+            self.stderr.write('%s\n' % e)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accounts/models.py	Sat May 05 17:10:48 2012 -0500
@@ -0,0 +1,90 @@
+"""Contains models for the accounts application"""
+
+import datetime
+import random
+import string
+import hashlib
+import base64
+
+from django.db import models
+from django.contrib.auth.models import User
+from django.conf import settings
+
+
+class IllegalUsername(models.Model):
+   """model to represent the list of illegal usernames"""
+   username = models.CharField(max_length=30, db_index=True)
+
+   def __unicode__(self):
+      return self.username
+
+   class Meta:
+      ordering = ('username', )
+
+
+class IllegalEmail(models.Model):
+   """model to represent the list of illegal/restricted email addresses"""
+   email = models.EmailField(db_index=True)
+
+   def __unicode__(self):
+      return self.email
+
+   class Meta:
+      ordering = ('email', )
+
+
+class PendingUserManager(models.Manager):
+   """user manager for PendingUser model"""
+
+   create_count = 0
+
+   def create_pending_user(self, username, email, password):
+      '''creates a new pending user and saves it to the database'''
+
+      temp_user = User()
+      temp_user.set_password(password)
+
+      now = datetime.datetime.now() 
+      pending_user = self.model(None, 
+            username, 
+            email, 
+            temp_user.password, 
+            now, 
+            self._make_key())
+
+      pending_user.save()
+      self.create_count += 1
+      return pending_user
+
+
+   def purge_expired(self):
+      expire_time = datetime.datetime.now() - datetime.timedelta(days=1)
+      expired_pending_users = self.filter(date_joined__lt=expire_time)
+      expired_pending_users.delete()
+
+
+   def _make_key(self):
+      s = ''.join(random.sample(string.printable, 8))
+      delta = datetime.date.today() - datetime.date(1846, 12, 28)
+      days = base64.urlsafe_b64encode(str(delta * 10))
+      key = hashlib.sha1(settings.SECRET_KEY +
+         unicode(self.create_count) +
+         unicode(s) +
+         unicode(days)).hexdigest()[::2]
+      return key
+
+
+class PendingUser(models.Model):
+   """model for holding users while they go through the email registration cycle"""
+
+   username = models.CharField(max_length=30, db_index=True)
+   email = models.EmailField()
+   password = models.CharField(max_length=128)
+   date_joined = models.DateTimeField(default=datetime.datetime.now, db_index=True)
+   key = models.CharField(max_length=20, editable=True)
+
+   objects = PendingUserManager()
+
+   def __unicode__(self):
+      return self.username
+