--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/articles/admin.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,21 @@
+"""
+Automatic admin definitions for the articles application.
+
+"""
+from django.contrib import admin
+from django.conf import settings
+
+from articles.models import Article
+
+
+class ArticleAdmin(admin.ModelAdmin):
+    save_on_top = True
+    list_filter = ['date']
+    list_display = ['title', 'date']
+    search_fields = ['text', 'title']
+
+    class Media:
+        js = settings.THIRD_PARTY_JS['tiny_mce']
+
+
+admin.site.register(Article, ArticleAdmin)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/articles/management/commands/import_old_articles.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,59 @@
+"""
+import_old_articles.py - For importing articles from the older version of this
+website.
+
+"""
+import datetime
+
+from django.conf import settings
+from django.core.management.base import LabelCommand
+from django.utils import simplejson as json
+from django.utils.html import linebreaks
+import textile
+
+from articles.models import Article
+
+
+class Command(LabelCommand):
+    args = '<filename filename ...>'
+    help = 'Imports older articles in JSON format'
+
+    def handle_label(self, filename, **options):
+        """
+        Process the file of older articles in JSON. Convert to the new model
+        scheme.
+
+        """
+        with open(filename, 'rb') as f:
+            items = json.load(f)
+
+        for item in items:
+            if item['model'] == 'band.article':
+                self.process_item(item)
+
+    def process_item(self, item):
+
+        fields = item['fields']
+
+        content = fields['text'].strip()
+        if fields['markup_enabled']:
+            text = textile.textile(content, encoding='utf-8', output='utf-8')
+        else:
+            text = linebreaks(fields['text'])
+
+        source = linebreaks(fields['source'].strip())
+
+        pdf = fields['pdf'].strip()
+        if pdf:
+            pdf = u"%s%s" % (settings.MEDIA_URL, pdf.replace('\\', '/'))
+
+        article = Article(
+                id=item['pk'],
+                title=fields['title'].strip(),
+                date=datetime.datetime.strptime(fields['date'], '%Y-%m-%d'),
+                text=text,
+                source=source,
+                url=fields['url'].strip(),
+                pdf=pdf)
+
+        article.save()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/articles/models.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,28 @@
+"""
+Models for the articles application.
+
+"""
+from django.db import models
+
+
+class Article(models.Model):
+    title = models.CharField(max_length=64)
+    date = models.DateTimeField(db_index=True)
+    text = models.TextField()
+    source = models.TextField(help_text="Enter the source/author for the "
+            "article, copyright info, etc; it will appear under the article.")
+    url = models.URLField(blank=True,
+            help_text = 'Link to original article; optional')
+    pdf = models.FileField(upload_to = 'pdf/articles/%Y/%m/%d/', blank=True,
+            help_text="If you want to make the original article available as "
+            "a PDF download, you may upload it here.")
+
+    def __unicode__(self):
+        return self.title
+
+    class Meta:
+        ordering = ['-date']
+
+    @models.permalink
+    def get_absolute_url(self):
+        return ('articles-item', [], {'pk': str(self.id)})

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/articles/urls.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,20 @@
+"""
+Urls for the articles application.
+
+"""
+from django.conf.urls import patterns, url
+from django.views.generic import DetailView, ListView
+
+from articles.models import Article
+
+
+urlpatterns = patterns('',
+   url(r'^$',
+       ListView.as_view(
+           model=Article,
+           context_object_name='article_list'),
+       name='articles-index'),
+   url(r'^(?P<pk>\d+)/$',
+       DetailView.as_view(model=Article, context_object_name='article'),
+       name='articles-item')
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/articles/views.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,1 @@
+# Create your views here.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/band/admin.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,83 @@
+"""
+Automatic admin definitions for the band models.
+
+"""
+from django.contrib import admin
+
+from band.models import Album
+from band.models import AlbumMerchant
+from band.models import AlbumTrack
+from band.models import Gear
+from band.models import LabelRelease
+from band.models import Member
+from band.models import Merchandise
+from band.models import RecordLabel
+
+
+class GearInline(admin.TabularInline):
+    model = Gear
+
+
+class GearAdmin(admin.ModelAdmin):
+    list_display = ['item', 'member']
+    list_filter = ['member']
+
+
+class MemberAdmin(admin.ModelAdmin):
+    list_display = ['name', 'instrument', 'is_active']
+    inlines = [GearInline]
+
+
+class AlbumTrackInline(admin.TabularInline):
+    model = AlbumTrack
+
+
+class AlbumTrackAdmin(admin.ModelAdmin):
+    list_display = ['track_name', 'album']
+    list_filter = ['album']
+
+
+class LabelReleaseInline(admin.TabularInline):
+    model = LabelRelease
+
+
+class LabelReleaseAdmin(admin.ModelAdmin):
+    list_display = ['catalog_number', 'album', 'record_label', 'release_date']
+    list_filter = ['record_label', 'album']
+
+
+class RecordLabelAdmin(admin.ModelAdmin):
+    inlines = [LabelReleaseInline]
+
+
+class AlbumMerchantInline(admin.TabularInline):
+    model = AlbumMerchant
+
+
+class AlbumMerchantAdmin(admin.ModelAdmin):
+    list_display = ['name', 'album']
+    list_filter = ['album']
+
+
+class AlbumAdmin(admin.ModelAdmin):
+    save_on_top = True
+    inlines = [
+        AlbumTrackInline,
+        LabelReleaseInline,
+        AlbumMerchantInline,
+    ]
+
+
+class MerchandiseAdmin(admin.ModelAdmin):
+    list_display = ['name', 'price', 'in_stock']
+    list_filter = ['in_stock']
+
+
+admin.site.register(Gear, GearAdmin)
+admin.site.register(Member, MemberAdmin)
+admin.site.register(AlbumTrack, AlbumTrackAdmin)
+admin.site.register(LabelRelease, LabelReleaseAdmin)
+admin.site.register(RecordLabel, RecordLabelAdmin)
+admin.site.register(AlbumMerchant, AlbumMerchantAdmin)
+admin.site.register(Album, AlbumAdmin)
+admin.site.register(Merchandise, MerchandiseAdmin)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/band/management/commands/import_old_band.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,149 @@
+"""
+import_old_band.py - For importing band models from the older version of this
+website.
+
+"""
+import datetime
+
+from django.core.management.base import LabelCommand
+from django.utils import simplejson as json
+from django.utils.html import linebreaks
+from photologue.models import Photo
+
+from band.models import (Member, Gear, RecordLabel, Album, AlbumTrack,
+        LabelRelease, AlbumMerchant, Merchandise)
+
+
+class Command(LabelCommand):
+    args = '<filename filename ...>'
+    help = 'Imports older band model objects in JSON format'
+
+    members = {}
+    albums = {}
+    labels = {}
+
+    def handle_label(self, filename, **options):
+        """
+        Process the file of older model objects in JSON. Convert to the new model
+        scheme.
+
+        """
+        with open(filename, 'rb') as f:
+            items = json.load(f)
+
+        for item in items:
+            if item['model'] == 'band.member':
+                self.process_member(item)
+            elif item['model'] == 'band.gear':
+                self.process_gear(item)
+            elif item['model'] == 'band.record_label':
+                self.process_record_label(item)
+            elif item['model'] == 'band.album':
+                self.process_album(item)
+            elif item['model'] == 'band.album_track':
+                self.process_track(item)
+            elif item['model'] == 'band.label_release':
+                self.process_release(item)
+            elif item['model'] == 'band.album_merchant':
+                self.process_merchant(item)
+            elif item['model'] == 'band.merchandise':
+                self.process_merch(item)
+
+    def process_member(self, item):
+
+        fields = item['fields']
+
+        start_date = datetime.datetime.strptime(fields['start_date'], '%Y-%m-%d')
+
+        if fields['end_date'] == u'1985-01-01':
+            end_date = None
+        else:
+            end_date = datetime.datetime.strptime(fields['end_date'], '%Y-%m-%d')
+
+        member = Member(id=item['pk'],
+                name=fields['name'],
+                nickname=fields['nickname'],
+                instrument=fields['instrument'],
+                bio=fields['bio'],
+                photo=fields['photo'],
+                order=int(fields['order']),
+                is_active=fields['is_active'],
+                start_date=start_date,
+                end_date=end_date,
+                email=fields['email'])
+        member.save()
+        self.members[member.id] = member
+
+    def process_gear(self, item):
+        fields = item['fields']
+
+        gear = Gear(id=item['pk'],
+                member=self.members[int(fields['member'])],
+                item=fields['item'])
+        gear.save()
+
+    def process_record_label(self, item):
+        fields = item['fields']
+
+        label = RecordLabel(id=item['pk'],
+                url=fields['url'],
+                name=fields['name'])
+        label.save()
+        self.labels[label.id] = label
+        
+    def process_album(self, item):
+        fields = item['fields']
+
+        photo = Photo.objects.get(id=fields['photo'])
+
+        album = Album(id=item['pk'],
+                title=fields['title'],
+                photo=photo,
+                desc=fields['desc'])
+        album.save()
+        self.albums[album.id] = album
+
+    def process_track(self, item):
+        fields = item['fields']
+
+        track = AlbumTrack(id=item['pk'],
+                album=self.albums[int(fields['album'])],
+                track_number=int(fields['track_number']),
+                track_name=fields['track_name'])
+        track.save()
+
+    def process_release(self, item):
+        fields = item['fields']
+
+        release = LabelRelease(id=item['pk'],
+                record_label=self.labels[int(fields['record_label'])],
+                album=self.albums[int(fields['album'])],
+                catalog_number=fields['catalog_number'],
+                release_date=datetime.datetime.strptime(
+                    fields['release_date'], '%Y-%m-%d'))
+
+        release.save()
+
+    def process_merchant(self, item):
+        fields = item['fields']
+
+        merchant = AlbumMerchant(id=item['pk'],
+                album=self.albums[int(fields['album'])],
+                url=fields['url'],
+                name=fields['name'])
+
+        merchant.save()
+
+    def process_merch(self, item):
+        fields = item['fields']
+
+        photo = Photo.objects.get(id=fields['photo'])
+
+        merch = Merchandise(id=item['pk'],
+                name=fields['name'],
+                desc=fields['desc'],
+                price=fields['price'],
+                in_stock=fields['in_stock'],
+                photo=photo)
+
+        merch.save()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/band/models.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,111 @@
+"""
+Models for the band application.
+
+"""
+from django.db import models
+
+from photologue.models import Photo
+
+
+class Member(models.Model):
+    name = models.CharField(max_length=50)
+    nickname = models.CharField(max_length=50, blank=True)
+    instrument = models.CharField(max_length=255)
+    bio = models.TextField(blank=True)
+    photo = models.ImageField(upload_to='images/bio/', blank=True)
+    order = models.SmallIntegerField(
+        help_text = "Controls order of display; lower numbers displayed first")
+    is_active = models.BooleanField()
+    start_date = models.DateField()
+    end_date = models.DateField(blank=True,
+        null=True,
+        help_text="Only used if the member is not active")
+    email = models.EmailField()
+
+    def __unicode__(self):
+        return self.name
+
+    class Meta:
+        ordering = ['-is_active', 'name']
+
+
+class Gear(models.Model):
+    member = models.ForeignKey(Member)
+    item = models.CharField(max_length=255)
+
+    def __unicode__(self):
+        return self.item
+
+    class Meta:
+        verbose_name_plural = 'Gear List'
+
+
+class RecordLabel(models.Model):
+    name = models.CharField(max_length=64)
+    url = models.URLField(max_length=200)
+
+    def __unicode__(self):
+        return self.name
+
+
+class Album(models.Model):
+    title = models.CharField(max_length=64)
+    photo = models.ForeignKey(Photo)
+    desc = models.TextField(blank=True)
+
+    def __unicode__(self):
+        return self.title
+
+
+class AlbumTrack(models.Model):
+    album = models.ForeignKey(Album, related_name='tracks')
+    track_number = models.SmallIntegerField()
+    track_name = models.CharField(max_length=64)
+
+    def __unicode__(self):
+        return self.track_name
+
+    class Meta:
+        verbose_name = 'Album Track'
+        ordering = ['album', 'track_number']
+
+
+class LabelRelease(models.Model):
+    record_label = models.ForeignKey(RecordLabel)
+    album = models.ForeignKey(Album, related_name='labels')
+    catalog_number = models.CharField(max_length=32)
+    release_date = models.DateField()
+
+    def __unicode__(self):
+        return u'%s %s %s' % (self.record_label.name, self.album.title,
+                self.catalog_number)
+
+    class Meta:
+        verbose_name = 'Label Release'
+
+
+class AlbumMerchant(models.Model):
+    album = models.ForeignKey(Album, related_name='merchants')
+    name = models.CharField(max_length=64)
+    url = models.URLField(max_length=200)
+
+    def __unicode__(self):
+        return u'%s (%s)' % (self.name, self.album.title)
+
+    class Meta:
+        verbose_name = 'Album Merchant'
+        ordering = ['name']
+
+
+class Merchandise(models.Model):
+    name = models.CharField(max_length=64)
+    desc = models.TextField()
+    price = models.DecimalField(max_digits=5, decimal_places=2)
+    in_stock = models.BooleanField()
+    photo = models.ForeignKey(Photo)
+
+    def __unicode__(self):
+        return self.name
+
+    class Meta:
+        verbose_name_plural = "Merchandise"

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/band/urls.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,13 @@
+"""
+Urls for the band application.
+
+"""
+from django.conf.urls import patterns, url
+
+urlpatterns = patterns('band.views',
+   url(r'^bio/$', 'bio', name='band-bio'),
+   url(r'^buy/$', 'buy', name='band-buy'),
+   url(r'^contact/$', 'contact', name='band-contact'),
+   url(r'^photos/$', 'photos_index', name='band-photo_index'),
+   url(r'^photos/(\d+)$', 'photo_detail', name='band-photo_detail'),
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/band/views.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,57 @@
+"""
+Views for the band application.
+
+"""
+import random
+
+from django.shortcuts import render
+from django.shortcuts import get_object_or_404
+from photologue.models import Gallery
+from photologue.models import Photo
+
+from band.models import Member, Merchandise, Album
+
+
+def bio(request):
+    members = Member.objects.exclude(is_active=0)
+    return render(request, 'band/bio.html', {'members': members})
+
+
+def photos_index(request):
+    galleries = Gallery.objects.values('title', 'id').order_by('-id')
+
+    photo_ids = Photo.objects.filter(is_public=True).values_list('id',
+            flat=True)
+    photo_ids = random.sample(photo_ids, 4)
+    random_photos = Photo.objects.filter(id__in=photo_ids)
+
+    return render(request, 'band/photos.html', {
+        'galleries': galleries,
+        'random_photos': random_photos,
+    })
+
+
+def photo_detail(request, id):
+    gallery = get_object_or_404(Gallery, pk=id)
+    photos = gallery.photos.order_by('id')
+
+    return render(request, 'band/photo_detail.html', {
+        'gallery': gallery,
+        'photos': photos,
+    })
+
+
+def buy(request):
+    albums = Album.objects.all().order_by('-id')
+    merchandise = Merchandise.objects.all().order_by('-id')
+    return render(request, 'band/buy.html', {
+        'albums': albums, 
+        'merchandise': merchandise, 
+    })
+
+
+def contact(request):
+    band = Member.objects.exclude(is_active=0).order_by('order')
+    return render(request, 'band/contact.html', {
+        'band': band,
+    })

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/admin.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,41 @@
+"""
+Automatic admin definitions for the email_list application.
+
+"""
+from django.contrib import admin
+from django.conf.urls import patterns, url
+from django.shortcuts import render, redirect
+
+from email_list.models import Subscriber
+from email_list.forms import AdminEmailForm
+
+
+class SubscriberAdmin(admin.ModelAdmin):
+    list_display = ['__unicode__', 'location', 'status']
+    list_filter = ['status']
+    search_fields = ['name', 'email']
+
+    def get_urls(self):
+        urls = super(SubscriberAdmin, self).get_urls()
+        my_urls = patterns('',
+            url(r'^send_mail/$',
+                self.admin_site.admin_view(self.send_mail),
+                name='email_list-admin_mail'),
+        )
+        return my_urls + urls
+
+    def send_mail(self, request):
+        if request.method == 'POST':
+            form = AdminEmailForm(request.POST)
+            if form.is_valid():
+                n = form.save()
+                msg = '%d mailing list emails sent' % n
+                self.message_user(request, msg)
+                return redirect('admin:index')
+        else:
+            form = AdminEmailForm()
+
+        return render(request, 'email_list/admin_mail.html', {'form': form})
+
+
+admin.site.register(Subscriber, SubscriberAdmin)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/forms.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,155 @@
+"""
+Forms for the email_list application.
+
+"""
+from django import forms
+from django.conf import settings
+from django.core.urlresolvers import reverse
+from django.core.mail import send_mail, send_mass_mail
+from django.template.loader import render_to_string
+
+from email_list.models import Subscriber
+
+
+SUBSCRIBE_OPTS = [('sub', 'Subscribe'), ('unsub', 'Unsubscribe')]
+
+ALREADY_SUBSCRIBED = "This email address is already subscribed."
+NOT_SUBSCRIBED = "This email address is not on our list."
+
+
+class SubscriberForm(forms.Form):
+    name = forms.CharField(max_length=64, required=False)
+    email = forms.EmailField()
+    location = forms.CharField(max_length=64, required=False)
+    option = forms.ChoiceField(choices=SUBSCRIBE_OPTS)
+
+    def clean(self):
+        """
+        This method ensures the appropriate action can be carried out and raises
+        a validation error if not.
+
+        """
+        email = self.cleaned_data['email']
+
+        if self.cleaned_data['option'] == 'sub':
+            # is the user already subscribed (active)?
+            try:
+                subscriber = Subscriber.objects.get(email=email)
+            except Subscriber.DoesNotExist:
+                subscriber = Subscriber(email=email,
+                        name=self.cleaned_data['name'],
+                        location=self.cleaned_data['location'])
+            else:
+                if subscriber.is_active():
+                    raise forms.ValidationError(ALREADY_SUBSCRIBED)
+        else:
+            # is the user already unsubscribed or not subscribed?
+            try:
+                subscriber = Subscriber.objects.get(email=email)
+            except Subscriber.DoesNotExist:
+                raise forms.ValidationError(NOT_SUBSCRIBED)
+
+        # save the subscriber away for a future process() call
+        self.subscriber = subscriber
+
+        return self.cleaned_data
+
+    def is_subscribe(self):
+        """
+        This function can be called after an is_valid() call to determine if the
+        request was for a subscribe or unsubscribe.
+
+        """
+        return self.cleaned_data['option'] == 'sub'
+
+    def process(self):
+        """
+        Call this function if is_valid() returns True. It carries out the user's
+        subscription request. 
+
+        """
+        if self.is_subscribe():
+            self.subscriber.set_pending()
+        else:
+            self.subscriber.set_leaving()
+
+        self.subscriber.save()
+        send_email(self.subscriber)
+
+
+class AdminEmailForm(forms.Form):
+    subject = forms.CharField(max_length=255, required=True, label='Subject:',
+        widget=forms.TextInput(attrs={'class': 'vTextField required',
+            'size': '120'}))
+    message = forms.CharField(label='Message:',
+        widget=forms.Textarea(attrs={'class': 'vLargeTextField required'}))
+
+    def __init__(self, *args, **kwargs):
+        initial = kwargs.pop('initial', {})
+        if 'subject' not in initial:
+            initial['subject'] = '[%s] ' % settings.BAND_CONFIG['BAND_NAME']
+            kwargs['initial'] = initial
+
+        super(AdminEmailForm, self).__init__(*args, **kwargs)
+
+    def save(self):
+        """
+        Call this function if is_valid() to send the mass email.
+        Returns the number of mails sent.
+
+        """
+        subject = self.cleaned_data['subject']
+        message = self.cleaned_data['message']
+        return send_mail_to_subscribers(subject, message)
+
+
+def send_email(subscriber):
+    """
+    This function sends out the appropriate email for the given subscriber.
+
+    """
+    config = settings.BAND_CONFIG
+    band = config['BAND_NAME']
+    from_email = config['BAND_EMAIL']
+
+    url = "http://%s%s" % (config['BAND_DOMAIN'],
+            reverse('email_list-confirm', kwargs={'key': subscriber.key}))
+
+    if subscriber.is_pending():
+        email_template = 'email_list/email_subscribe.txt'
+    else:
+        email_template = 'email_list/email_unsubscribe.txt'
+
+    msg = render_to_string(email_template, {
+        'band': band, 
+        'url': url, 
+        'band_domain': config['BAND_DOMAIN'],
+        })
+
+    subject = "[%s] Mailing List Confirmation" % band
+
+    send_mail(subject, msg, from_email, [subscriber.email])
+
+
+def send_mail_to_subscribers(subject, message):
+    """
+    Send an email to each mailing list subscriber with the given subject and
+    message.
+    Returns the number of messages sent.
+
+    """
+    config = settings.BAND_CONFIG
+    unsubscribe_url = "http://%s%s" % (config['BAND_DOMAIN'],
+              reverse('email_list-main'))
+
+    msg = render_to_string('email_list/mailing_list.txt', {
+        'band': config['BAND_NAME'],
+        'unsubscribe_url': unsubscribe_url,
+        'message': message,
+        })
+
+    mail_data = [(subject, msg, config['BAND_EMAIL'], [subscriber]) for
+            subscriber in Subscriber.objects.values_list('email', flat=True)]
+
+    send_mass_mail(mail_data)
+    return len(mail_data)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/management/commands/import_old_email_list.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,51 @@
+"""
+import_old_email_list.py - For importing the email list from the older version
+of this website.
+
+"""
+import datetime
+
+from django.core.management.base import LabelCommand
+from django.utils import simplejson as json
+
+from email_list.models import Subscriber
+
+
+class Command(LabelCommand):
+    args = '<filename filename ...>'
+    help = 'Imports older email list data in JSON format'
+
+    def handle_label(self, filename, **options):
+        """
+        Process the file of older email list data in JSON. Convert to the new
+        model scheme.
+
+        """
+        with open(filename, 'rb') as f:
+            items = json.load(f)
+
+        for item in items:
+            if item['model'] == 'band.fan':
+                self.process_item(item)
+
+    def process_item(self, item):
+
+        fields = item['fields']
+
+        # Only process 'active' subscribers because the new application
+        # has changed the key generation scheme.
+
+        if fields['status'] != 'A':
+            return
+
+        subscriber = Subscriber(
+                id=item['pk'],
+                name=fields['name'].strip(),
+                email=fields['email'].strip(),
+                location=fields['location'].strip(),
+                status='A',
+                key='',
+                status_date=datetime.datetime.strptime(
+                    fields['status_date'], '%Y-%m-%d'))
+
+        subscriber.save()                    

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/models.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,69 @@
+"""
+Models for the email_list application.
+
+"""
+import base64
+import datetime
+import hashlib
+
+from django.db import models
+from django.conf import settings
+
+
+class Subscriber(models.Model):
+    status_codes = [('P', 'Pending'), ('A', 'Active'), ('L', 'Leaving')]
+    key_length = 28
+
+    name = models.CharField(max_length=64, blank=True)
+    email = models.EmailField(db_index=True)
+    location = models.CharField(max_length=64, blank=True)
+    status = models.CharField(max_length=1, choices=status_codes, default='A')
+    key = models.CharField(max_length=key_length, editable=False, blank=True,
+            db_index=True)
+    status_date = models.DateTimeField(editable=False)
+
+    class Meta:
+        ordering = ['name', 'email']
+
+    def __unicode__(self):
+        if self.name:
+            return u'%s <%s>' % (self.name, self.email)
+        return self.email
+
+    def save(self, *args, **kwargs):
+        if not self.pk and not self.status_date:
+            self.status_date = datetime.datetime.now()
+
+        super(Subscriber, self).save(*args, **kwargs)
+
+    def set_pending(self):
+        self.status = 'P'
+        self.status_date = datetime.datetime.now()
+        self.gen_key()
+
+    def set_active(self):
+        self.status = 'A'
+        self.status_date = datetime.datetime.now()
+        self.key = ''
+
+    def set_leaving(self):
+        self.status = 'L'
+        self.status_date = datetime.datetime.now()
+        self.gen_key()
+
+    def is_pending(self):
+        return self.status == 'P'
+
+    def is_leaving(self):
+        return self.status == 'L'
+
+    def is_active(self):
+        return self.status == 'A'
+
+    def gen_key(self):
+        source = (settings.SECRET_KEY + self.email + self.name + self.location +
+                self.status + self.status_date.isoformat())
+
+        sha = hashlib.sha1()
+        sha.update(source)
+        self.key = base64.urlsafe_b64encode(sha.digest())

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/tests/__init__.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,2 @@
+from model_tests import *
+from view_tests import *

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/tests/model_tests.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,76 @@
+"""
+Model tests for the email_list application.
+
+"""
+import datetime
+
+from django.test import TestCase
+
+from email_list.models import Subscriber
+
+
+class SubscriberTestCase(TestCase):
+
+    def test_auto_save(self):
+
+        sub = Subscriber(name='', location='', email='test@example.com')
+        sub.save()
+
+        now = datetime.datetime.now()
+        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
+
+        self.assertTrue(sub.status == 'A')
+        self.assertTrue(sub.is_active())
+        self.failIf(sub.is_pending())
+        self.failIf(sub.is_leaving())
+
+    def test_set_pending(self):
+
+        sub = Subscriber(name='', location='', email='test@example.com')
+        sub.set_pending()
+
+        now = datetime.datetime.now()
+        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
+
+        self.assertTrue(sub.status == 'P')
+        self.failIf(sub.is_active())
+        self.assertTrue(sub.is_pending())
+        self.failIf(sub.is_leaving())
+
+        self.assertTrue(len(sub.key) == sub.key_length)
+
+    def test_set_active(self):
+
+        sub = Subscriber(name='', location='', email='test@example.com')
+        sub.set_active()
+
+        now = datetime.datetime.now()
+        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
+
+        self.assertTrue(sub.status == 'A')
+        self.assertTrue(sub.is_active())
+        self.failIf(sub.is_pending())
+        self.failIf(sub.is_leaving())
+
+    def test_set_leaving(self):
+
+        sub = Subscriber(name='', location='', email='test@example.com')
+        sub.set_leaving()
+
+        now = datetime.datetime.now()
+        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
+
+        self.assertTrue(sub.status == 'L')
+        self.failIf(sub.is_active())
+        self.failIf(sub.is_pending())
+        self.assertTrue(sub.is_leaving())
+
+        self.assertTrue(len(sub.key) == sub.key_length)
+
+    def test_gen_key(self):
+
+        sub = Subscriber(name='', location='', email='test@example.com')
+        sub.status_date = datetime.datetime.now()
+        sub.gen_key()
+        self.assertTrue(len(sub.key) == sub.key_length)
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/tests/view_tests.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,213 @@
+"""
+View tests for the email_list application.
+
+"""
+from django.test import TestCase
+from django.core.urlresolvers import reverse
+from django.core import mail
+
+from email_list.models import Subscriber
+import email_list.forms
+
+
+SUB_PARAMS = {
+    'name': 'John Doe',
+    'email': 'j.doe@example.com',
+    'location': 'USA',
+    'option': 'sub'
+}
+
+UNSUB_PARAMS = {
+    'name': '',
+    'email': SUB_PARAMS['email'],
+    'location': '',
+    'option': 'unsub'
+}
+
+class EmailListTestCase(TestCase):
+
+    def test_already_subscribed(self):
+        """
+        Test that subscribing twice fails with a form error.
+
+        """
+        sub = Subscriber(email=SUB_PARAMS['email'])
+        sub.set_active()
+        sub.save()
+
+        # Post a subscribe request
+
+        response = self.client.post(
+                reverse('email_list-main'),
+                SUB_PARAMS,
+                follow=True)
+
+        self.assertTrue(response.status_code, 200)
+        self.assertEqual(len(response.redirect_chain), 0)
+        self.assertContains(response, email_list.forms.ALREADY_SUBSCRIBED)
+
+    def test_not_subscribed(self):
+        """
+        Test that unsubscribing without being subscribed fails with a form error.
+
+        """
+        # Post a unsubscribe request
+
+        response = self.client.post(
+                reverse('email_list-main'),
+                UNSUB_PARAMS,
+                follow=True)
+
+        self.assertTrue(response.status_code, 200)
+        self.assertEqual(len(response.redirect_chain), 0)
+        self.assertContains(response, email_list.forms.NOT_SUBSCRIBED)
+
+    def test_normal_cycle(self):
+        """
+        Test a normal subscribe and unsubscribe cycle.
+
+        """
+        self.do_test_subscribe()
+        self.do_test_unsubscribe()
+
+    def test_subscribe_if_pending(self):
+        """
+        Ensure you can subscribe if you are already pending.
+
+        """
+        sub = Subscriber(email=SUB_PARAMS['email'])
+        sub.set_pending()
+        sub.save()
+        self.do_test_subscribe()
+
+    def test_subscribe_if_leaving(self):
+        """
+        Ensure you can subscribe if you are leaving.
+
+        """
+        sub = Subscriber(email=SUB_PARAMS['email'])
+        sub.set_leaving()
+        sub.save()
+        self.do_test_subscribe()
+
+    def test_unsubscribe_if_leaving(self):
+        """
+        Ensure you can unsubscribe if you are already leaving.
+
+        """
+        sub = Subscriber(email=SUB_PARAMS['email'])
+        sub.set_leaving()
+        sub.save()
+        self.do_test_unsubscribe()
+
+    def do_test_subscribe(self):
+        # Get the form view
+        response = self.client.get(reverse('email_list-main'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'email_list/subscribe_form.html')
+
+        # Post a subscribe request
+
+        response = self.client.post(
+                reverse('email_list-main'),
+                SUB_PARAMS,
+                follow=True)
+
+        self.assertTrue(response.status_code, 200)
+        self.assertEqual(len(response.redirect_chain), 1)
+        self.assertEqual(response.redirect_chain[0][0],
+                'http://testserver' + reverse('email_list-request_subscribe'))
+        self.assertEqual(response.redirect_chain[0][1], 302)
+
+        # verify subscriber is in pending state
+
+        try:
+            subscriber = Subscriber.objects.get(email=SUB_PARAMS['email'])
+        except Subscriber.DoesNotExist:
+            self.fail("No pending subscriber")
+
+        self.assertTrue(subscriber.is_pending())
+
+        # test email sent
+        self.do_test_email(subscriber)
+
+        # simulate a confirm click
+
+        response = self.client.get(
+                reverse('email_list-confirm', kwargs={'key': subscriber.key}),
+                follow=True)
+
+        self.assertTrue(response.status_code, 200)
+        self.assertEqual(len(response.redirect_chain), 1)
+        self.assertEqual(response.redirect_chain[0][0],
+                'http://testserver' + reverse('email_list-subscribed'))
+        self.assertEqual(response.redirect_chain[0][1], 302)
+
+        # verify active user
+        try:
+            subscriber = Subscriber.objects.get(email=SUB_PARAMS['email'])
+        except Subscriber.DoesNotExist:
+            self.fail("No active subscriber")
+
+        self.assertTrue(subscriber.is_active())
+
+    def do_test_unsubscribe(self):
+        # Get the form view
+        response = self.client.get(reverse('email_list-main'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'email_list/subscribe_form.html')
+
+        # Post a unsubscribe request
+
+        response = self.client.post(
+                reverse('email_list-main'),
+                UNSUB_PARAMS,
+                follow=True)
+
+        self.assertTrue(response.status_code, 200)
+        self.assertEqual(len(response.redirect_chain), 1)
+        self.assertEqual(response.redirect_chain[0][0],
+                'http://testserver' + reverse('email_list-request_unsubscribe'))
+        self.assertEqual(response.redirect_chain[0][1], 302)
+
+        # verify subscriber is in leaving state
+
+        try:
+            subscriber = Subscriber.objects.get(email=UNSUB_PARAMS['email'])
+        except Subscriber.DoesNotExist:
+            self.fail("No pending subscriber")
+
+        self.assertTrue(subscriber.is_leaving())
+
+        # test email sent
+        self.do_test_email(subscriber)
+
+        # simulate a click to unsubscribe
+
+        response = self.client.get(
+                reverse('email_list-confirm', kwargs={'key': subscriber.key}),
+                follow=True)
+
+        self.assertTrue(response.status_code, 200)
+        self.assertEqual(len(response.redirect_chain), 1)
+        self.assertEqual(response.redirect_chain[0][0],
+                'http://testserver' + reverse('email_list-unsubscribed'))
+        self.assertEqual(response.redirect_chain[0][1], 302)
+
+        # verify subscription has been removed
+
+        self.assertRaises(Subscriber.DoesNotExist, Subscriber.objects.get,
+                email=UNSUB_PARAMS['email'])
+
+    def do_test_email(self, subscriber):
+        """
+        Tests to see if the confirmation email was sent.
+
+        """
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertEqual(len(mail.outbox[0].to), 1)
+        self.assertEqual(mail.outbox[0].to[0], subscriber.email)
+        self.assertTrue(str(mail.outbox[0].message()).count(subscriber.key) > 0)
+
+        # clear outbox
+        mail.outbox = []

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/urls.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,28 @@
+"""
+Urls for the email_list application.
+
+"""
+from django.conf.urls import patterns, url
+from django.views.generic import TemplateView
+
+
+urlpatterns = patterns('email_list.views',
+   url(r'^$',
+       'mailing_list',
+       name='email_list-main'),
+   url(r'^confirm/(?P<key>[-a-zA-Z0-9_=]{28})/$',
+       'confirm',
+       name='email_list-confirm'),
+   url(r'^request/subscribe/$',
+       TemplateView.as_view(template_name='email_list/subscribe_request.html'),
+       name='email_list-request_subscribe'),
+   url(r'^request/unsubscribe/$',
+       TemplateView.as_view(template_name='email_list/unsubscribe_request.html'),
+       name='email_list-request_unsubscribe'),
+   url(r'^subscribed/$',
+       TemplateView.as_view(template_name='email_list/subscribed.html'),
+       name='email_list-subscribed'),
+   url(r'^unsubscribed/$',
+       TemplateView.as_view(template_name='email_list/unsubscribed.html'),
+       name='email_list-unsubscribed'),
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email_list/views.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,56 @@
+"""
+Views for the email_list application.
+
+"""
+import logging
+
+from django.http import HttpResponseServerError
+from django.shortcuts import render, redirect, get_object_or_404
+
+from email_list.forms import SubscriberForm
+from email_list.models import Subscriber
+
+
+logger = logging.getLogger(__name__)
+
+
+def mailing_list(request):
+    """
+    The main view for handling email list actions (subscribe or unsubscribe).
+
+    """
+    if request.method == 'POST':
+        form = SubscriberForm(request.POST)
+        if form.is_valid():
+            form.process()
+
+            if form.is_subscribe():
+                return redirect('email_list-request_subscribe')
+            else:
+                return redirect('email_list-request_unsubscribe')
+
+    else:
+        form = SubscriberForm()
+
+    return render(request, 'email_list/subscribe_form.html', {'form': form})
+
+
+def confirm(request, key):
+    """
+    This view handles the confirmation of a subscribe or unsubscribe action.
+
+    """
+    subscriber = get_object_or_404(Subscriber, key=key)
+
+    if subscriber.is_pending():
+        subscriber.set_active()
+        subscriber.save()
+        return redirect('email_list-subscribed')
+    elif subscriber.is_leaving():
+        subscriber.delete()
+        return redirect('email_list-unsubscribed')
+
+    # This should not happen
+    logger.error("Trying to confirm subscriber %d, but status is %s",
+            subscriber.pk, subscriber.status)
+    return HttpResponseServerError()

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gigs/admin.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,57 @@
+"""
+Automatic admin definitions for the gigs application.
+
+"""
+from django.contrib import admin
+
+from gigs.models import Band, City, Country, Gig, State, Venue
+
+
+class CityInline(admin.TabularInline):
+    model = City
+
+
+class CityAdmin(admin.ModelAdmin):
+    list_display = ['name', 'state', 'country']
+    list_filter = ['state']
+    search_fields = ['name']
+
+    def queryset(self, request):
+        qs = super(CityAdmin, self).queryset(request)
+        return qs.select_related('state', 'country')
+
+
+class StateAdmin(admin.ModelAdmin):
+    inlines = [CityInline]
+
+
+class VenueAdmin(admin.ModelAdmin):
+    list_filter = ['city__name']
+    list_display = ['name', 'city']
+    search_fields = ['name']
+
+    def queryset(self, request):
+        qs = super(VenueAdmin, self).queryset(request)
+        return qs.select_related('city', 'city__state', 'city__country')
+
+
+class BandAdmin(admin.ModelAdmin):
+    search_fields = ['name']
+
+
+class GigAdmin(admin.ModelAdmin):
+    list_filter = ['date']
+    save_on_top = True
+    filter_horizontal = ['bands']
+
+    def queryset(self, request):
+        qs = super(GigAdmin, self).queryset(request)
+        return qs.select_related('venue')
+
+
+admin.site.register(Band, BandAdmin)
+admin.site.register(City, CityAdmin)
+admin.site.register(Country)
+admin.site.register(Gig, GigAdmin)
+admin.site.register(State, StateAdmin)
+admin.site.register(Venue, VenueAdmin)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gigs/models.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,97 @@
+"""
+Models for the gigs application.
+
+"""
+from django.db import models
+from django.contrib.localflavor.us.models import USStateField
+from django.contrib.localflavor.us.models import PhoneNumberField
+
+from photologue.models import Photo
+
+
+class Country(models.Model):
+    name = models.CharField(max_length=64)
+
+    class Meta:
+        ordering = ['name']
+        verbose_name_plural = 'Countries'
+
+    def __unicode__(self):
+        return self.name
+
+
+class State(models.Model):
+    name = models.CharField(max_length=16)
+    abbrev = USStateField()
+
+    class Meta:
+        ordering = ['name']
+
+    def __unicode__(self):
+        return self.name
+
+
+class City(models.Model):
+    name = models.CharField(max_length=50)
+    state = models.ForeignKey(State, null=True, blank=True)
+    country = models.ForeignKey(Country, null=True, blank=True)
+
+    class Meta:
+        verbose_name_plural = 'Cities'
+        ordering = ['name']
+
+    def __unicode__(self):
+        if self.state:
+            return u'%s, %s' % (self.name, self.state.abbrev)
+        
+        return self.name
+
+
+class Venue(models.Model):
+    name = models.CharField(max_length=50)
+    url = models.URLField(blank=True)
+    address = models.CharField(max_length=255, blank=True)
+    phone = PhoneNumberField(help_text="Format: XXX-XXX-XXXX", blank=True)
+    city = models.ForeignKey(City)
+
+    class Meta:
+        ordering = ['name']
+
+    def __unicode__(self):
+        return self.name
+
+
+class Band(models.Model):
+    name = models.CharField(max_length=64)
+    url = models.URLField(blank=True)
+
+    class Meta:
+        ordering = ['name']
+
+    def __unicode__(self):
+        return self.name
+
+
+class Gig(models.Model):
+    title = models.CharField(max_length=50, blank=True,
+            help_text="Optional; e.g. Some Festival")
+    url = models.URLField(blank=True,
+            help_text="Optional; e.g. Some Festival's Website")
+    date = models.DateField(db_index=True)
+    time = models.TimeField(null=True, blank=True)
+    venue = models.ForeignKey(Venue, null=True, blank=True)
+    notes = models.TextField(blank=True)
+    bands = models.ManyToManyField(Band, blank=True)
+    flyer = models.ForeignKey(Photo, null=True, blank=True,
+            related_name='gig_flyers')
+
+    def __unicode__(self):
+        if self.title:
+            return u'%s %s %s' % (self.date.strftime('%m/%d/%Y'), self.title, self.venue.name)
+        elif self.venue:
+            return u'%s %s' % (self.date.strftime('%m/%d/%Y'), self.venue.name)
+        else:
+            return self.date.strftime('%m/%d/%Y')
+
+    class Meta:
+        ordering = ['-date', 'time']

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gigs/templatetags/gig_tags.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,22 @@
+"""
+Template tags for the gigs application.
+
+"""
+import datetime
+
+from django import template
+
+from gigs.models import Gig
+
+
+register = template.Library()
+
+
+@register.inclusion_tag('gigs/upcoming_gigs_tag.html')
+def upcoming_gigs():
+
+    gigs = Gig.objects.filter(date__gte=datetime.date.today).select_related(
+        'flyer', 'venue', 'venue__city', 'venue__city__state',
+        'venue__city__country').order_by('date')[:10]
+
+    return {'gigs': gigs}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gigs/urls.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,19 @@
+"""
+Urls for the gigs application.
+
+"""
+from django.conf.urls import patterns, url
+from django.views.generic import ListView
+
+from gigs.models import Gig
+
+
+urlpatterns = patterns('',
+   url(r'^$', 'gigs.views.gigs', name='gigs-index'),
+   url(r'^flyers/$',
+       ListView.as_view(
+           queryset=Gig.objects.exclude(flyer__isnull=True).select_related('flyer'),
+           template_name='gigs/flyers.html',
+           context_object_name='gig_list'),
+       name='gigs-flyers')
+)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gigs/views.py	Sat Apr 14 16:40:29 2012 -0500
@@ -0,0 +1,76 @@
+"""
+Views for the gigs application.
+
+"""
+import collections
+import datetime
+
+from django.db import connection
+from django.shortcuts import render
+
+from gigs.models import Band, Gig
+
+
+def gigs(request):
+    """
+    This view function renders the main gigs view, showing upcoming and past
+    gigs as well as some statistics.
+
+    """
+    today = datetime.date.today()
+    gigs = Gig.objects.select_related('venue', 'flyer', 'venue__city',
+              'venue__city__state', 'venue__city__country')
+    upcoming = []
+    previous = []
+
+    # To avoid many, many database hits in the template, we get all the
+    # bands out at once. We also get the many-to-many intermediate table
+    # that Django generated for us so we can associate bands to gigs.
+    # Since we don't know about this table we drop into raw SQL to get
+    # the contents.
+
+    bands = dict((band.id, band) for band in Band.objects.all())
+    cursor = connection.cursor()
+    cursor.execute('SELECT * FROM gigs_gig_bands')
+    gig_bands = collections.defaultdict(list)
+    for row in cursor.fetchall():
+        gig_bands[row[1]].append(bands[row[2]])
+
+    for gig in gigs:
+        gig.bands_ = gig_bands[gig.id]
+        if gig.date >= today:
+            upcoming.append(gig)
+        else:
+            previous.append(gig)
+
+    upcoming.reverse()
+
+    stats = {}
+    venues = set()
+    cities = set()
+    states = set()
+    countries = set()
+    for gig in previous:
+        venues.add(gig.venue.id)
+        cities.add(gig.venue.city.id)
+        if gig.venue.city.state:
+            states.add(gig.venue.city.state.id)
+        if gig.venue.city.country:
+            countries.add(gig.venue.city.country.id)
+
+    stats['count'] = len(previous)
+    stats['venues'] = len(venues)
+    stats['cities'] = len(cities)
+    stats['states'] = len(states)
+    stats['countries'] = len(countries)
+    stats['bands'] = len(bands)
+
+    flyer_gigs = Gig.objects.exclude(flyer__isnull = True).select_related(
+         'venue', 'flyer').order_by('-date')
+
+    return render(request, 'gigs/gigs.html', {
+         'upcoming' : upcoming,
+         'previous' : previous,
+         'stats' : stats,
+         'flyer_gigs' : flyer_gigs,
+         })

--- a/madeira/apache/madeira.wsgi	Sat Apr 14 15:49:28 2012 -0500
+++ b/madeira/apache/madeira.wsgi	Sat Apr 14 16:40:29 2012 -0500
@@ -7,7 +7,6 @@
 site.addsitedir('/home/var/django-sites/virtualenvs/madeira/lib/python2.5/site-packages')
 
 sys.path.append('/home/var/django-sites/virtualenvs/madeira/madeira')
-sys.path.append('/home/var/django-sites/virtualenvs/madeira/madeira/madeira')
 os.environ['PYTHON_EGG_CACHE'] = '/home/var/django-sites/virtualenvs/madeira/eggs/'
 
 

--- a/madeira/articles/admin.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,21 +0,0 @@
-"""
-Automatic admin definitions for the articles application.
-
-"""
-from django.contrib import admin
-from django.conf import settings
-
-from articles.models import Article
-
-
-class ArticleAdmin(admin.ModelAdmin):
-    save_on_top = True
-    list_filter = ['date']
-    list_display = ['title', 'date']
-    search_fields = ['text', 'title']
-
-    class Media:
-        js = settings.THIRD_PARTY_JS['tiny_mce']
-
-
-admin.site.register(Article, ArticleAdmin)

--- a/madeira/articles/management/commands/import_old_articles.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,59 +0,0 @@
-"""
-import_old_articles.py - For importing articles from the older version of this
-website.
-
-"""
-import datetime
-
-from django.conf import settings
-from django.core.management.base import LabelCommand
-from django.utils import simplejson as json
-from django.utils.html import linebreaks
-import textile
-
-from articles.models import Article
-
-
-class Command(LabelCommand):
-    args = '<filename filename ...>'
-    help = 'Imports older articles in JSON format'
-
-    def handle_label(self, filename, **options):
-        """
-        Process the file of older articles in JSON. Convert to the new model
-        scheme.
-
-        """
-        with open(filename, 'rb') as f:
-            items = json.load(f)
-
-        for item in items:
-            if item['model'] == 'band.article':
-                self.process_item(item)
-
-    def process_item(self, item):
-
-        fields = item['fields']
-
-        content = fields['text'].strip()
-        if fields['markup_enabled']:
-            text = textile.textile(content, encoding='utf-8', output='utf-8')
-        else:
-            text = linebreaks(fields['text'])
-
-        source = linebreaks(fields['source'].strip())
-
-        pdf = fields['pdf'].strip()
-        if pdf:
-            pdf = u"%s%s" % (settings.MEDIA_URL, pdf.replace('\\', '/'))
-
-        article = Article(
-                id=item['pk'],
-                title=fields['title'].strip(),
-                date=datetime.datetime.strptime(fields['date'], '%Y-%m-%d'),
-                text=text,
-                source=source,
-                url=fields['url'].strip(),
-                pdf=pdf)
-
-        article.save()

--- a/madeira/articles/models.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,28 +0,0 @@
-"""
-Models for the articles application.
-
-"""
-from django.db import models
-
-
-class Article(models.Model):
-    title = models.CharField(max_length=64)
-    date = models.DateTimeField(db_index=True)
-    text = models.TextField()
-    source = models.TextField(help_text="Enter the source/author for the "
-            "article, copyright info, etc; it will appear under the article.")
-    url = models.URLField(blank=True,
-            help_text = 'Link to original article; optional')
-    pdf = models.FileField(upload_to = 'pdf/articles/%Y/%m/%d/', blank=True,
-            help_text="If you want to make the original article available as "
-            "a PDF download, you may upload it here.")
-
-    def __unicode__(self):
-        return self.title
-
-    class Meta:
-        ordering = ['-date']
-
-    @models.permalink
-    def get_absolute_url(self):
-        return ('articles-item', [], {'pk': str(self.id)})

--- a/madeira/articles/urls.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-"""
-Urls for the articles application.
-
-"""
-from django.conf.urls import patterns, url
-from django.views.generic import DetailView, ListView
-
-from articles.models import Article
-
-
-urlpatterns = patterns('',
-   url(r'^$',
-       ListView.as_view(
-           model=Article,
-           context_object_name='article_list'),
-       name='articles-index'),
-   url(r'^(?P<pk>\d+)/$',
-       DetailView.as_view(model=Article, context_object_name='article'),
-       name='articles-item')
-)

--- a/madeira/articles/views.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-# Create your views here.

--- a/madeira/band/admin.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,83 +0,0 @@
-"""
-Automatic admin definitions for the band models.
-
-"""
-from django.contrib import admin
-
-from band.models import Album
-from band.models import AlbumMerchant
-from band.models import AlbumTrack
-from band.models import Gear
-from band.models import LabelRelease
-from band.models import Member
-from band.models import Merchandise
-from band.models import RecordLabel
-
-
-class GearInline(admin.TabularInline):
-    model = Gear
-
-
-class GearAdmin(admin.ModelAdmin):
-    list_display = ['item', 'member']
-    list_filter = ['member']
-
-
-class MemberAdmin(admin.ModelAdmin):
-    list_display = ['name', 'instrument', 'is_active']
-    inlines = [GearInline]
-
-
-class AlbumTrackInline(admin.TabularInline):
-    model = AlbumTrack
-
-
-class AlbumTrackAdmin(admin.ModelAdmin):
-    list_display = ['track_name', 'album']
-    list_filter = ['album']
-
-
-class LabelReleaseInline(admin.TabularInline):
-    model = LabelRelease
-
-
-class LabelReleaseAdmin(admin.ModelAdmin):
-    list_display = ['catalog_number', 'album', 'record_label', 'release_date']
-    list_filter = ['record_label', 'album']
-
-
-class RecordLabelAdmin(admin.ModelAdmin):
-    inlines = [LabelReleaseInline]
-
-
-class AlbumMerchantInline(admin.TabularInline):
-    model = AlbumMerchant
-
-
-class AlbumMerchantAdmin(admin.ModelAdmin):
-    list_display = ['name', 'album']
-    list_filter = ['album']
-
-
-class AlbumAdmin(admin.ModelAdmin):
-    save_on_top = True
-    inlines = [
-        AlbumTrackInline,
-        LabelReleaseInline,
-        AlbumMerchantInline,
-    ]
-
-
-class MerchandiseAdmin(admin.ModelAdmin):
-    list_display = ['name', 'price', 'in_stock']
-    list_filter = ['in_stock']
-
-
-admin.site.register(Gear, GearAdmin)
-admin.site.register(Member, MemberAdmin)
-admin.site.register(AlbumTrack, AlbumTrackAdmin)
-admin.site.register(LabelRelease, LabelReleaseAdmin)
-admin.site.register(RecordLabel, RecordLabelAdmin)
-admin.site.register(AlbumMerchant, AlbumMerchantAdmin)
-admin.site.register(Album, AlbumAdmin)
-admin.site.register(Merchandise, MerchandiseAdmin)

--- a/madeira/band/management/commands/import_old_band.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,149 +0,0 @@
-"""
-import_old_band.py - For importing band models from the older version of this
-website.
-
-"""
-import datetime
-
-from django.core.management.base import LabelCommand
-from django.utils import simplejson as json
-from django.utils.html import linebreaks
-from photologue.models import Photo
-
-from band.models import (Member, Gear, RecordLabel, Album, AlbumTrack,
-        LabelRelease, AlbumMerchant, Merchandise)
-
-
-class Command(LabelCommand):
-    args = '<filename filename ...>'
-    help = 'Imports older band model objects in JSON format'
-
-    members = {}
-    albums = {}
-    labels = {}
-
-    def handle_label(self, filename, **options):
-        """
-        Process the file of older model objects in JSON. Convert to the new model
-        scheme.
-
-        """
-        with open(filename, 'rb') as f:
-            items = json.load(f)
-
-        for item in items:
-            if item['model'] == 'band.member':
-                self.process_member(item)
-            elif item['model'] == 'band.gear':
-                self.process_gear(item)
-            elif item['model'] == 'band.record_label':
-                self.process_record_label(item)
-            elif item['model'] == 'band.album':
-                self.process_album(item)
-            elif item['model'] == 'band.album_track':
-                self.process_track(item)
-            elif item['model'] == 'band.label_release':
-                self.process_release(item)
-            elif item['model'] == 'band.album_merchant':
-                self.process_merchant(item)
-            elif item['model'] == 'band.merchandise':
-                self.process_merch(item)
-
-    def process_member(self, item):
-
-        fields = item['fields']
-
-        start_date = datetime.datetime.strptime(fields['start_date'], '%Y-%m-%d')
-
-        if fields['end_date'] == u'1985-01-01':
-            end_date = None
-        else:
-            end_date = datetime.datetime.strptime(fields['end_date'], '%Y-%m-%d')
-
-        member = Member(id=item['pk'],
-                name=fields['name'],
-                nickname=fields['nickname'],
-                instrument=fields['instrument'],
-                bio=fields['bio'],
-                photo=fields['photo'],
-                order=int(fields['order']),
-                is_active=fields['is_active'],
-                start_date=start_date,
-                end_date=end_date,
-                email=fields['email'])
-        member.save()
-        self.members[member.id] = member
-
-    def process_gear(self, item):
-        fields = item['fields']
-
-        gear = Gear(id=item['pk'],
-                member=self.members[int(fields['member'])],
-                item=fields['item'])
-        gear.save()
-
-    def process_record_label(self, item):
-        fields = item['fields']
-
-        label = RecordLabel(id=item['pk'],
-                url=fields['url'],
-                name=fields['name'])
-        label.save()
-        self.labels[label.id] = label
-        
-    def process_album(self, item):
-        fields = item['fields']
-
-        photo = Photo.objects.get(id=fields['photo'])
-
-        album = Album(id=item['pk'],
-                title=fields['title'],
-                photo=photo,
-                desc=fields['desc'])
-        album.save()
-        self.albums[album.id] = album
-
-    def process_track(self, item):
-        fields = item['fields']
-
-        track = AlbumTrack(id=item['pk'],
-                album=self.albums[int(fields['album'])],
-                track_number=int(fields['track_number']),
-                track_name=fields['track_name'])
-        track.save()
-
-    def process_release(self, item):
-        fields = item['fields']
-
-        release = LabelRelease(id=item['pk'],
-                record_label=self.labels[int(fields['record_label'])],
-                album=self.albums[int(fields['album'])],
-                catalog_number=fields['catalog_number'],
-                release_date=datetime.datetime.strptime(
-                    fields['release_date'], '%Y-%m-%d'))
-
-        release.save()
-
-    def process_merchant(self, item):
-        fields = item['fields']
-
-        merchant = AlbumMerchant(id=item['pk'],
-                album=self.albums[int(fields['album'])],
-                url=fields['url'],
-                name=fields['name'])
-
-        merchant.save()
-
-    def process_merch(self, item):
-        fields = item['fields']
-
-        photo = Photo.objects.get(id=fields['photo'])
-
-        merch = Merchandise(id=item['pk'],
-                name=fields['name'],
-                desc=fields['desc'],
-                price=fields['price'],
-                in_stock=fields['in_stock'],
-                photo=photo)
-
-        merch.save()

--- a/madeira/band/models.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,111 +0,0 @@
-"""
-Models for the band application.
-
-"""
-from django.db import models
-
-from photologue.models import Photo
-
-
-class Member(models.Model):
-    name = models.CharField(max_length=50)
-    nickname = models.CharField(max_length=50, blank=True)
-    instrument = models.CharField(max_length=255)
-    bio = models.TextField(blank=True)
-    photo = models.ImageField(upload_to='images/bio/', blank=True)
-    order = models.SmallIntegerField(
-        help_text = "Controls order of display; lower numbers displayed first")
-    is_active = models.BooleanField()
-    start_date = models.DateField()
-    end_date = models.DateField(blank=True,
-        null=True,
-        help_text="Only used if the member is not active")
-    email = models.EmailField()
-
-    def __unicode__(self):
-        return self.name
-
-    class Meta:
-        ordering = ['-is_active', 'name']
-
-
-class Gear(models.Model):
-    member = models.ForeignKey(Member)
-    item = models.CharField(max_length=255)
-
-    def __unicode__(self):
-        return self.item
-
-    class Meta:
-        verbose_name_plural = 'Gear List'
-
-
-class RecordLabel(models.Model):
-    name = models.CharField(max_length=64)
-    url = models.URLField(max_length=200)
-
-    def __unicode__(self):
-        return self.name
-
-
-class Album(models.Model):
-    title = models.CharField(max_length=64)
-    photo = models.ForeignKey(Photo)
-    desc = models.TextField(blank=True)
-
-    def __unicode__(self):
-        return self.title
-
-
-class AlbumTrack(models.Model):
-    album = models.ForeignKey(Album, related_name='tracks')
-    track_number = models.SmallIntegerField()
-    track_name = models.CharField(max_length=64)
-
-    def __unicode__(self):
-        return self.track_name
-
-    class Meta:
-        verbose_name = 'Album Track'
-        ordering = ['album', 'track_number']
-
-
-class LabelRelease(models.Model):
-    record_label = models.ForeignKey(RecordLabel)
-    album = models.ForeignKey(Album, related_name='labels')
-    catalog_number = models.CharField(max_length=32)
-    release_date = models.DateField()
-
-    def __unicode__(self):
-        return u'%s %s %s' % (self.record_label.name, self.album.title,
-                self.catalog_number)
-
-    class Meta:
-        verbose_name = 'Label Release'
-
-
-class AlbumMerchant(models.Model):
-    album = models.ForeignKey(Album, related_name='merchants')
-    name = models.CharField(max_length=64)
-    url = models.URLField(max_length=200)
-
-    def __unicode__(self):
-        return u'%s (%s)' % (self.name, self.album.title)
-
-    class Meta:
-        verbose_name = 'Album Merchant'
-        ordering = ['name']
-
-
-class Merchandise(models.Model):
-    name = models.CharField(max_length=64)
-    desc = models.TextField()
-    price = models.DecimalField(max_digits=5, decimal_places=2)
-    in_stock = models.BooleanField()
-    photo = models.ForeignKey(Photo)
-
-    def __unicode__(self):
-        return self.name
-
-    class Meta:
-        verbose_name_plural = "Merchandise"

--- a/madeira/band/urls.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-"""
-Urls for the band application.
-
-"""
-from django.conf.urls import patterns, url
-
-urlpatterns = patterns('band.views',
-   url(r'^bio/$', 'bio', name='band-bio'),
-   url(r'^buy/$', 'buy', name='band-buy'),
-   url(r'^contact/$', 'contact', name='band-contact'),
-   url(r'^photos/$', 'photos_index', name='band-photo_index'),
-   url(r'^photos/(\d+)$', 'photo_detail', name='band-photo_detail'),
-)

--- a/madeira/band/views.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
-"""
-Views for the band application.
-
-"""
-import random
-
-from django.shortcuts import render
-from django.shortcuts import get_object_or_404
-from photologue.models import Gallery
-from photologue.models import Photo
-
-from band.models import Member, Merchandise, Album
-
-
-def bio(request):
-    members = Member.objects.exclude(is_active=0)
-    return render(request, 'band/bio.html', {'members': members})
-
-
-def photos_index(request):
-    galleries = Gallery.objects.values('title', 'id').order_by('-id')
-
-    photo_ids = Photo.objects.filter(is_public=True).values_list('id',
-            flat=True)
-    photo_ids = random.sample(photo_ids, 4)
-    random_photos = Photo.objects.filter(id__in=photo_ids)
-
-    return render(request, 'band/photos.html', {
-        'galleries': galleries,
-        'random_photos': random_photos,
-    })
-
-
-def photo_detail(request, id):
-    gallery = get_object_or_404(Gallery, pk=id)
-    photos = gallery.photos.order_by('id')
-
-    return render(request, 'band/photo_detail.html', {
-        'gallery': gallery,
-        'photos': photos,
-    })
-
-
-def buy(request):
-    albums = Album.objects.all().order_by('-id')
-    merchandise = Merchandise.objects.all().order_by('-id')
-    return render(request, 'band/buy.html', {
-        'albums': albums, 
-        'merchandise': merchandise, 
-    })
-
-
-def contact(request):
-    band = Member.objects.exclude(is_active=0).order_by('order')
-    return render(request, 'band/contact.html', {
-        'band': band,
-    })

--- a/madeira/email_list/admin.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-"""
-Automatic admin definitions for the email_list application.
-
-"""
-from django.contrib import admin
-from django.conf.urls import patterns, url
-from django.shortcuts import render, redirect
-
-from email_list.models import Subscriber
-from email_list.forms import AdminEmailForm
-
-
-class SubscriberAdmin(admin.ModelAdmin):
-    list_display = ['__unicode__', 'location', 'status']
-    list_filter = ['status']
-    search_fields = ['name', 'email']
-
-    def get_urls(self):
-        urls = super(SubscriberAdmin, self).get_urls()
-        my_urls = patterns('',
-            url(r'^send_mail/$',
-                self.admin_site.admin_view(self.send_mail),
-                name='email_list-admin_mail'),
-        )
-        return my_urls + urls
-
-    def send_mail(self, request):
-        if request.method == 'POST':
-            form = AdminEmailForm(request.POST)
-            if form.is_valid():
-                n = form.save()
-                msg = '%d mailing list emails sent' % n
-                self.message_user(request, msg)
-                return redirect('admin:index')
-        else:
-            form = AdminEmailForm()
-
-        return render(request, 'email_list/admin_mail.html', {'form': form})
-
-
-admin.site.register(Subscriber, SubscriberAdmin)

--- a/madeira/email_list/forms.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,155 +0,0 @@
-"""
-Forms for the email_list application.
-
-"""
-from django import forms
-from django.conf import settings
-from django.core.urlresolvers import reverse
-from django.core.mail import send_mail, send_mass_mail
-from django.template.loader import render_to_string
-
-from email_list.models import Subscriber
-
-
-SUBSCRIBE_OPTS = [('sub', 'Subscribe'), ('unsub', 'Unsubscribe')]
-
-ALREADY_SUBSCRIBED = "This email address is already subscribed."
-NOT_SUBSCRIBED = "This email address is not on our list."
-
-
-class SubscriberForm(forms.Form):
-    name = forms.CharField(max_length=64, required=False)
-    email = forms.EmailField()
-    location = forms.CharField(max_length=64, required=False)
-    option = forms.ChoiceField(choices=SUBSCRIBE_OPTS)
-
-    def clean(self):
-        """
-        This method ensures the appropriate action can be carried out and raises
-        a validation error if not.
-
-        """
-        email = self.cleaned_data['email']
-
-        if self.cleaned_data['option'] == 'sub':
-            # is the user already subscribed (active)?
-            try:
-                subscriber = Subscriber.objects.get(email=email)
-            except Subscriber.DoesNotExist:
-                subscriber = Subscriber(email=email,
-                        name=self.cleaned_data['name'],
-                        location=self.cleaned_data['location'])
-            else:
-                if subscriber.is_active():
-                    raise forms.ValidationError(ALREADY_SUBSCRIBED)
-        else:
-            # is the user already unsubscribed or not subscribed?
-            try:
-                subscriber = Subscriber.objects.get(email=email)
-            except Subscriber.DoesNotExist:
-                raise forms.ValidationError(NOT_SUBSCRIBED)
-
-        # save the subscriber away for a future process() call
-        self.subscriber = subscriber
-
-        return self.cleaned_data
-
-    def is_subscribe(self):
-        """
-        This function can be called after an is_valid() call to determine if the
-        request was for a subscribe or unsubscribe.
-
-        """
-        return self.cleaned_data['option'] == 'sub'
-
-    def process(self):
-        """
-        Call this function if is_valid() returns True. It carries out the user's
-        subscription request. 
-
-        """
-        if self.is_subscribe():
-            self.subscriber.set_pending()
-        else:
-            self.subscriber.set_leaving()
-
-        self.subscriber.save()
-        send_email(self.subscriber)
-
-
-class AdminEmailForm(forms.Form):
-    subject = forms.CharField(max_length=255, required=True, label='Subject:',
-        widget=forms.TextInput(attrs={'class': 'vTextField required',
-            'size': '120'}))
-    message = forms.CharField(label='Message:',
-        widget=forms.Textarea(attrs={'class': 'vLargeTextField required'}))
-
-    def __init__(self, *args, **kwargs):
-        initial = kwargs.pop('initial', {})
-        if 'subject' not in initial:
-            initial['subject'] = '[%s] ' % settings.BAND_CONFIG['BAND_NAME']
-            kwargs['initial'] = initial
-
-        super(AdminEmailForm, self).__init__(*args, **kwargs)
-
-    def save(self):
-        """
-        Call this function if is_valid() to send the mass email.
-        Returns the number of mails sent.
-
-        """
-        subject = self.cleaned_data['subject']
-        message = self.cleaned_data['message']
-        return send_mail_to_subscribers(subject, message)
-
-
-def send_email(subscriber):
-    """
-    This function sends out the appropriate email for the given subscriber.
-
-    """
-    config = settings.BAND_CONFIG
-    band = config['BAND_NAME']
-    from_email = config['BAND_EMAIL']
-
-    url = "http://%s%s" % (config['BAND_DOMAIN'],
-            reverse('email_list-confirm', kwargs={'key': subscriber.key}))
-
-    if subscriber.is_pending():
-        email_template = 'email_list/email_subscribe.txt'
-    else:
-        email_template = 'email_list/email_unsubscribe.txt'
-
-    msg = render_to_string(email_template, {
-        'band': band, 
-        'url': url, 
-        'band_domain': config['BAND_DOMAIN'],
-        })
-
-    subject = "[%s] Mailing List Confirmation" % band
-
-    send_mail(subject, msg, from_email, [subscriber.email])
-
-
-def send_mail_to_subscribers(subject, message):
-    """
-    Send an email to each mailing list subscriber with the given subject and
-    message.
-    Returns the number of messages sent.
-
-    """
-    config = settings.BAND_CONFIG
-    unsubscribe_url = "http://%s%s" % (config['BAND_DOMAIN'],
-              reverse('email_list-main'))
-
-    msg = render_to_string('email_list/mailing_list.txt', {
-        'band': config['BAND_NAME'],
-        'unsubscribe_url': unsubscribe_url,
-        'message': message,
-        })
-
-    mail_data = [(subject, msg, config['BAND_EMAIL'], [subscriber]) for
-            subscriber in Subscriber.objects.values_list('email', flat=True)]
-
-    send_mass_mail(mail_data)
-    return len(mail_data)

--- a/madeira/email_list/management/commands/import_old_email_list.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-"""
-import_old_email_list.py - For importing the email list from the older version
-of this website.
-
-"""
-import datetime
-
-from django.core.management.base import LabelCommand
-from django.utils import simplejson as json
-
-from email_list.models import Subscriber
-
-
-class Command(LabelCommand):
-    args = '<filename filename ...>'
-    help = 'Imports older email list data in JSON format'
-
-    def handle_label(self, filename, **options):
-        """
-        Process the file of older email list data in JSON. Convert to the new
-        model scheme.
-
-        """
-        with open(filename, 'rb') as f:
-            items = json.load(f)
-
-        for item in items:
-            if item['model'] == 'band.fan':
-                self.process_item(item)
-
-    def process_item(self, item):
-
-        fields = item['fields']
-
-        # Only process 'active' subscribers because the new application
-        # has changed the key generation scheme.
-
-        if fields['status'] != 'A':
-            return
-
-        subscriber = Subscriber(
-                id=item['pk'],
-                name=fields['name'].strip(),
-                email=fields['email'].strip(),
-                location=fields['location'].strip(),
-                status='A',
-                key='',
-                status_date=datetime.datetime.strptime(
-                    fields['status_date'], '%Y-%m-%d'))
-
-        subscriber.save()                    

--- a/madeira/email_list/models.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,69 +0,0 @@
-"""
-Models for the email_list application.
-
-"""
-import base64
-import datetime
-import hashlib
-
-from django.db import models
-from django.conf import settings
-
-
-class Subscriber(models.Model):
-    status_codes = [('P', 'Pending'), ('A', 'Active'), ('L', 'Leaving')]
-    key_length = 28
-
-    name = models.CharField(max_length=64, blank=True)
-    email = models.EmailField(db_index=True)
-    location = models.CharField(max_length=64, blank=True)
-    status = models.CharField(max_length=1, choices=status_codes, default='A')
-    key = models.CharField(max_length=key_length, editable=False, blank=True,
-            db_index=True)
-    status_date = models.DateTimeField(editable=False)
-
-    class Meta:
-        ordering = ['name', 'email']
-
-    def __unicode__(self):
-        if self.name:
-            return u'%s <%s>' % (self.name, self.email)
-        return self.email
-
-    def save(self, *args, **kwargs):
-        if not self.pk and not self.status_date:
-            self.status_date = datetime.datetime.now()
-
-        super(Subscriber, self).save(*args, **kwargs)
-
-    def set_pending(self):
-        self.status = 'P'
-        self.status_date = datetime.datetime.now()
-        self.gen_key()
-
-    def set_active(self):
-        self.status = 'A'
-        self.status_date = datetime.datetime.now()
-        self.key = ''
-
-    def set_leaving(self):
-        self.status = 'L'
-        self.status_date = datetime.datetime.now()
-        self.gen_key()
-
-    def is_pending(self):
-        return self.status == 'P'
-
-    def is_leaving(self):
-        return self.status == 'L'
-
-    def is_active(self):
-        return self.status == 'A'
-
-    def gen_key(self):
-        source = (settings.SECRET_KEY + self.email + self.name + self.location +
-                self.status + self.status_date.isoformat())
-
-        sha = hashlib.sha1()
-        sha.update(source)
-        self.key = base64.urlsafe_b64encode(sha.digest())

--- a/madeira/email_list/tests/__init__.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2 +0,0 @@
-from model_tests import *
-from view_tests import *

--- a/madeira/email_list/tests/model_tests.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,76 +0,0 @@
-"""
-Model tests for the email_list application.
-
-"""
-import datetime
-
-from django.test import TestCase
-
-from email_list.models import Subscriber
-
-
-class SubscriberTestCase(TestCase):
-
-    def test_auto_save(self):
-
-        sub = Subscriber(name='', location='', email='test@example.com')
-        sub.save()
-
-        now = datetime.datetime.now()
-        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
-
-        self.assertTrue(sub.status == 'A')
-        self.assertTrue(sub.is_active())
-        self.failIf(sub.is_pending())
-        self.failIf(sub.is_leaving())
-
-    def test_set_pending(self):
-
-        sub = Subscriber(name='', location='', email='test@example.com')
-        sub.set_pending()
-
-        now = datetime.datetime.now()
-        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
-
-        self.assertTrue(sub.status == 'P')
-        self.failIf(sub.is_active())
-        self.assertTrue(sub.is_pending())
-        self.failIf(sub.is_leaving())
-
-        self.assertTrue(len(sub.key) == sub.key_length)
-
-    def test_set_active(self):
-
-        sub = Subscriber(name='', location='', email='test@example.com')
-        sub.set_active()
-
-        now = datetime.datetime.now()
-        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
-
-        self.assertTrue(sub.status == 'A')
-        self.assertTrue(sub.is_active())
-        self.failIf(sub.is_pending())
-        self.failIf(sub.is_leaving())
-
-    def test_set_leaving(self):
-
-        sub = Subscriber(name='', location='', email='test@example.com')
-        sub.set_leaving()
-
-        now = datetime.datetime.now()
-        self.assertTrue(now - sub.status_date < datetime.timedelta(seconds=2))
-
-        self.assertTrue(sub.status == 'L')
-        self.failIf(sub.is_active())
-        self.failIf(sub.is_pending())
-        self.assertTrue(sub.is_leaving())
-
-        self.assertTrue(len(sub.key) == sub.key_length)
-
-    def test_gen_key(self):
-
-        sub = Subscriber(name='', location='', email='test@example.com')
-        sub.status_date = datetime.datetime.now()
-        sub.gen_key()
-        self.assertTrue(len(sub.key) == sub.key_length)
-

--- a/madeira/email_list/tests/view_tests.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,213 +0,0 @@
-"""
-View tests for the email_list application.
-
-"""
-from django.test import TestCase
-from django.core.urlresolvers import reverse
-from django.core import mail
-
-from email_list.models import Subscriber
-import email_list.forms
-
-
-SUB_PARAMS = {
-    'name': 'John Doe',
-    'email': 'j.doe@example.com',
-    'location': 'USA',
-    'option': 'sub'
-}
-
-UNSUB_PARAMS = {
-    'name': '',
-    'email': SUB_PARAMS['email'],
-    'location': '',
-    'option': 'unsub'
-}
-
-class EmailListTestCase(TestCase):
-
-    def test_already_subscribed(self):
-        """
-        Test that subscribing twice fails with a form error.
-
-        """
-        sub = Subscriber(email=SUB_PARAMS['email'])
-        sub.set_active()
-        sub.save()
-
-        # Post a subscribe request
-
-        response = self.client.post(
-                reverse('email_list-main'),
-                SUB_PARAMS,
-                follow=True)
-
-        self.assertTrue(response.status_code, 200)
-        self.assertEqual(len(response.redirect_chain), 0)
-        self.assertContains(response, email_list.forms.ALREADY_SUBSCRIBED)
-
-    def test_not_subscribed(self):
-        """
-        Test that unsubscribing without being subscribed fails with a form error.
-
-        """
-        # Post a unsubscribe request
-
-        response = self.client.post(
-                reverse('email_list-main'),
-                UNSUB_PARAMS,
-                follow=True)
-
-        self.assertTrue(response.status_code, 200)
-        self.assertEqual(len(response.redirect_chain), 0)
-        self.assertContains(response, email_list.forms.NOT_SUBSCRIBED)
-
-    def test_normal_cycle(self):
-        """
-        Test a normal subscribe and unsubscribe cycle.
-
-        """
-        self.do_test_subscribe()
-        self.do_test_unsubscribe()
-
-    def test_subscribe_if_pending(self):
-        """
-        Ensure you can subscribe if you are already pending.
-
-        """
-        sub = Subscriber(email=SUB_PARAMS['email'])
-        sub.set_pending()
-        sub.save()
-        self.do_test_subscribe()
-
-    def test_subscribe_if_leaving(self):
-        """
-        Ensure you can subscribe if you are leaving.
-
-        """
-        sub = Subscriber(email=SUB_PARAMS['email'])
-        sub.set_leaving()
-        sub.save()
-        self.do_test_subscribe()
-
-    def test_unsubscribe_if_leaving(self):
-        """
-        Ensure you can unsubscribe if you are already leaving.
-
-        """
-        sub = Subscriber(email=SUB_PARAMS['email'])
-        sub.set_leaving()
-        sub.save()
-        self.do_test_unsubscribe()
-
-    def do_test_subscribe(self):
-        # Get the form view
-        response = self.client.get(reverse('email_list-main'))
-        self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, 'email_list/subscribe_form.html')
-
-        # Post a subscribe request
-
-        response = self.client.post(
-                reverse('email_list-main'),
-                SUB_PARAMS,
-                follow=True)
-
-        self.assertTrue(response.status_code, 200)
-        self.assertEqual(len(response.redirect_chain), 1)
-        self.assertEqual(response.redirect_chain[0][0],
-                'http://testserver' + reverse('email_list-request_subscribe'))
-        self.assertEqual(response.redirect_chain[0][1], 302)
-
-        # verify subscriber is in pending state
-
-        try:
-            subscriber = Subscriber.objects.get(email=SUB_PARAMS['email'])
-        except Subscriber.DoesNotExist:
-            self.fail("No pending subscriber")
-
-        self.assertTrue(subscriber.is_pending())
-
-        # test email sent
-        self.do_test_email(subscriber)
-
-        # simulate a confirm click
-
-        response = self.client.get(
-                reverse('email_list-confirm', kwargs={'key': subscriber.key}),
-                follow=True)
-
-        self.assertTrue(response.status_code, 200)
-        self.assertEqual(len(response.redirect_chain), 1)
-        self.assertEqual(response.redirect_chain[0][0],
-                'http://testserver' + reverse('email_list-subscribed'))
-        self.assertEqual(response.redirect_chain[0][1], 302)
-
-        # verify active user
-        try:
-            subscriber = Subscriber.objects.get(email=SUB_PARAMS['email'])
-        except Subscriber.DoesNotExist:
-            self.fail("No active subscriber")
-
-        self.assertTrue(subscriber.is_active())
-
-    def do_test_unsubscribe(self):
-        # Get the form view
-        response = self.client.get(reverse('email_list-main'))
-        self.assertEqual(response.status_code, 200)
-        self.assertTemplateUsed(response, 'email_list/subscribe_form.html')
-
-        # Post a unsubscribe request
-
-        response = self.client.post(
-                reverse('email_list-main'),
-                UNSUB_PARAMS,
-                follow=True)
-
-        self.assertTrue(response.status_code, 200)
-        self.assertEqual(len(response.redirect_chain), 1)
-        self.assertEqual(response.redirect_chain[0][0],
-                'http://testserver' + reverse('email_list-request_unsubscribe'))
-        self.assertEqual(response.redirect_chain[0][1], 302)
-
-        # verify subscriber is in leaving state
-
-        try:
-            subscriber = Subscriber.objects.get(email=UNSUB_PARAMS['email'])
-        except Subscriber.DoesNotExist:
-            self.fail("No pending subscriber")
-
-        self.assertTrue(subscriber.is_leaving())
-
-        # test email sent
-        self.do_test_email(subscriber)
-
-        # simulate a click to unsubscribe
-
-        response = self.client.get(
-                reverse('email_list-confirm', kwargs={'key': subscriber.key}),
-                follow=True)
-
-        self.assertTrue(response.status_code, 200)
-        self.assertEqual(len(response.redirect_chain), 1)
-        self.assertEqual(response.redirect_chain[0][0],
-                'http://testserver' + reverse('email_list-unsubscribed'))
-        self.assertEqual(response.redirect_chain[0][1], 302)
-
-        # verify subscription has been removed
-
-        self.assertRaises(Subscriber.DoesNotExist, Subscriber.objects.get,
-                email=UNSUB_PARAMS['email'])
-
-    def do_test_email(self, subscriber):
-        """
-        Tests to see if the confirmation email was sent.
-
-        """
-        self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(len(mail.outbox[0].to), 1)
-        self.assertEqual(mail.outbox[0].to[0], subscriber.email)
-        self.assertTrue(str(mail.outbox[0].message()).count(subscriber.key) > 0)
-
-        # clear outbox
-        mail.outbox = []

--- a/madeira/email_list/urls.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,28 +0,0 @@
-"""
-Urls for the email_list application.
-
-"""
-from django.conf.urls import patterns, url
-from django.views.generic import TemplateView
-
-
-urlpatterns = patterns('email_list.views',
-   url(r'^$',
-       'mailing_list',
-       name='email_list-main'),
-   url(r'^confirm/(?P<key>[-a-zA-Z0-9_=]{28})/$',
-       'confirm',
-       name='email_list-confirm'),
-   url(r'^request/subscribe/$',
-       TemplateView.as_view(template_name='email_list/subscribe_request.html'),
-       name='email_list-request_subscribe'),
-   url(r'^request/unsubscribe/$',
-       TemplateView.as_view(template_name='email_list/unsubscribe_request.html'),
-       name='email_list-request_unsubscribe'),
-   url(r'^subscribed/$',
-       TemplateView.as_view(template_name='email_list/subscribed.html'),
-       name='email_list-subscribed'),
-   url(r'^unsubscribed/$',
-       TemplateView.as_view(template_name='email_list/unsubscribed.html'),
-       name='email_list-unsubscribed'),
-)

--- a/madeira/email_list/views.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-"""
-Views for the email_list application.
-
-"""
-import logging
-
-from django.http import HttpResponseServerError
-from django.shortcuts import render, redirect, get_object_or_404
-
-from email_list.forms import SubscriberForm
-from email_list.models import Subscriber
-
-
-logger = logging.getLogger(__name__)
-
-
-def mailing_list(request):
-    """
-    The main view for handling email list actions (subscribe or unsubscribe).
-
-    """
-    if request.method == 'POST':
-        form = SubscriberForm(request.POST)
-        if form.is_valid():
-            form.process()
-
-            if form.is_subscribe():
-                return redirect('email_list-request_subscribe')
-            else:
-                return redirect('email_list-request_unsubscribe')
-
-    else:
-        form = SubscriberForm()
-
-    return render(request, 'email_list/subscribe_form.html', {'form': form})
-
-
-def confirm(request, key):
-    """
-    This view handles the confirmation of a subscribe or unsubscribe action.
-
-    """
-    subscriber = get_object_or_404(Subscriber, key=key)
-
-    if subscriber.is_pending():
-        subscriber.set_active()
-        subscriber.save()
-        return redirect('email_list-subscribed')
-    elif subscriber.is_leaving():
-        subscriber.delete()
-        return redirect('email_list-unsubscribed')
-
-    # This should not happen
-    logger.error("Trying to confirm subscriber %d, but status is %s",
-            subscriber.pk, subscriber.status)
-    return HttpResponseServerError()

--- a/madeira/gigs/admin.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
-"""
-Automatic admin definitions for the gigs application.
-
-"""
-from django.contrib import admin
-
-from gigs.models import Band, City, Country, Gig, State, Venue
-
-
-class CityInline(admin.TabularInline):
-    model = City
-
-
-class CityAdmin(admin.ModelAdmin):
-    list_display = ['name', 'state', 'country']
-    list_filter = ['state']
-    search_fields = ['name']
-
-    def queryset(self, request):
-        qs = super(CityAdmin, self).queryset(request)
-        return qs.select_related('state', 'country')
-
-
-class StateAdmin(admin.ModelAdmin):
-    inlines = [CityInline]
-
-
-class VenueAdmin(admin.ModelAdmin):
-    list_filter = ['city__name']
-    list_display = ['name', 'city']
-    search_fields = ['name']
-
-    def queryset(self, request):
-        qs = super(VenueAdmin, self).queryset(request)
-        return qs.select_related('city', 'city__state', 'city__country')
-
-
-class BandAdmin(admin.ModelAdmin):
-    search_fields = ['name']
-
-
-class GigAdmin(admin.ModelAdmin):
-    list_filter = ['date']
-    save_on_top = True
-    filter_horizontal = ['bands']
-
-    def queryset(self, request):
-        qs = super(GigAdmin, self).queryset(request)
-        return qs.select_related('venue')
-
-
-admin.site.register(Band, BandAdmin)
-admin.site.register(City, CityAdmin)
-admin.site.register(Country)
-admin.site.register(Gig, GigAdmin)
-admin.site.register(State, StateAdmin)
-admin.site.register(Venue, VenueAdmin)

--- a/madeira/gigs/models.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,97 +0,0 @@
-"""
-Models for the gigs application.
-
-"""
-from django.db import models
-from django.contrib.localflavor.us.models import USStateField
-from django.contrib.localflavor.us.models import PhoneNumberField
-
-from photologue.models import Photo
-
-
-class Country(models.Model):
-    name = models.CharField(max_length=64)
-
-    class Meta:
-        ordering = ['name']
-        verbose_name_plural = 'Countries'
-
-    def __unicode__(self):
-        return self.name
-
-
-class State(models.Model):
-    name = models.CharField(max_length=16)
-    abbrev = USStateField()
-
-    class Meta:
-        ordering = ['name']
-
-    def __unicode__(self):
-        return self.name
-
-
-class City(models.Model):
-    name = models.CharField(max_length=50)
-    state = models.ForeignKey(State, null=True, blank=True)
-    country = models.ForeignKey(Country, null=True, blank=True)
-
-    class Meta:
-        verbose_name_plural = 'Cities'
-        ordering = ['name']
-
-    def __unicode__(self):
-        if self.state:
-            return u'%s, %s' % (self.name, self.state.abbrev)
-        
-        return self.name
-
-
-class Venue(models.Model):
-    name = models.CharField(max_length=50)
-    url = models.URLField(blank=True)
-    address = models.CharField(max_length=255, blank=True)
-    phone = PhoneNumberField(help_text="Format: XXX-XXX-XXXX", blank=True)
-    city = models.ForeignKey(City)
-
-    class Meta:
-        ordering = ['name']
-
-    def __unicode__(self):
-        return self.name
-
-
-class Band(models.Model):
-    name = models.CharField(max_length=64)
-    url = models.URLField(blank=True)
-
-    class Meta:
-        ordering = ['name']
-
-    def __unicode__(self):
-        return self.name
-
-
-class Gig(models.Model):
-    title = models.CharField(max_length=50, blank=True,
-            help_text="Optional; e.g. Some Festival")
-    url = models.URLField(blank=True,
-            help_text="Optional; e.g. Some Festival's Website")
-    date = models.DateField(db_index=True)
-    time = models.TimeField(null=True, blank=True)
-    venue = models.ForeignKey(Venue, null=True, blank=True)
-    notes = models.TextField(blank=True)
-    bands = models.ManyToManyField(Band, blank=True)
-    flyer = models.ForeignKey(Photo, null=True, blank=True,
-            related_name='gig_flyers')
-
-    def __unicode__(self):
-        if self.title:
-            return u'%s %s %s' % (self.date.strftime('%m/%d/%Y'), self.title, self.venue.name)
-        elif self.venue:
-            return u'%s %s' % (self.date.strftime('%m/%d/%Y'), self.venue.name)
-        else:
-            return self.date.strftime('%m/%d/%Y')
-
-    class Meta:
-        ordering = ['-date', 'time']

--- a/madeira/gigs/templatetags/gig_tags.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-"""
-Template tags for the gigs application.
-
-"""
-import datetime
-
-from django import template
-
-from gigs.models import Gig
-
-
-register = template.Library()
-
-
-@register.inclusion_tag('gigs/upcoming_gigs_tag.html')
-def upcoming_gigs():
-
-    gigs = Gig.objects.filter(date__gte=datetime.date.today).select_related(
-        'flyer', 'venue', 'venue__city', 'venue__city__state',
-        'venue__city__country').order_by('date')[:10]
-
-    return {'gigs': gigs}

--- a/madeira/gigs/urls.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-"""
-Urls for the gigs application.
-
-"""
-from django.conf.urls import patterns, url
-from django.views.generic import ListView
-
-from gigs.models import Gig
-
-
-urlpatterns = patterns('',
-   url(r'^$', 'gigs.views.gigs', name='gigs-index'),
-   url(r'^flyers/$',
-       ListView.as_view(
-           queryset=Gig.objects.exclude(flyer__isnull=True).select_related('flyer'),
-           template_name='gigs/flyers.html',
-           context_object_name='gig_list'),
-       name='gigs-flyers')
-)

--- a/madeira/gigs/views.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,76 +0,0 @@
-"""
-Views for the gigs application.
-
-"""
-import collections
-import datetime
-
-from django.db import connection
-from django.shortcuts import render
-
-from gigs.models import Band, Gig
-
-
-def gigs(request):
-    """
-    This view function renders the main gigs view, showing upcoming and past
-    gigs as well as some statistics.
-
-    """
-    today = datetime.date.today()
-    gigs = Gig.objects.select_related('venue', 'flyer', 'venue__city',
-              'venue__city__state', 'venue__city__country')
-    upcoming = []
-    previous = []
-
-    # To avoid many, many database hits in the template, we get all the
-    # bands out at once. We also get the many-to-many intermediate table
-    # that Django generated for us so we can associate bands to gigs.
-    # Since we don't know about this table we drop into raw SQL to get
-    # the contents.
-
-    bands = dict((band.id, band) for band in Band.objects.all())
-    cursor = connection.cursor()
-    cursor.execute('SELECT * FROM gigs_gig_bands')
-    gig_bands = collections.defaultdict(list)
-    for row in cursor.fetchall():
-        gig_bands[row[1]].append(bands[row[2]])
-
-    for gig in gigs:
-        gig.bands_ = gig_bands[gig.id]
-        if gig.date >= today:
-            upcoming.append(gig)
-        else:
-            previous.append(gig)
-
-    upcoming.reverse()
-
-    stats = {}
-    venues = set()
-    cities = set()
-    states = set()
-    countries = set()
-    for gig in previous:
-        venues.add(gig.venue.id)
-        cities.add(gig.venue.city.id)
-        if gig.venue.city.state:
-            states.add(gig.venue.city.state.id)
-        if gig.venue.city.country:
-            countries.add(gig.venue.city.country.id)
-
-    stats['count'] = len(previous)
-    stats['venues'] = len(venues)
-    stats['cities'] = len(cities)
-    stats['states'] = len(states)
-    stats['countries'] = len(countries)
-    stats['bands'] = len(bands)
-
-    flyer_gigs = Gig.objects.exclude(flyer__isnull = True).select_related(
-         'venue', 'flyer').order_by('-date')
-
-    return render(request, 'gigs/gigs.html', {
-         'upcoming' : upcoming,
-         'previous' : previous,
-         'stats' : stats,
-         'flyer_gigs' : flyer_gigs,
-         })

--- a/madeira/manage.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-from django.core.management import execute_manager
-try:
-    import settings # Assumed to be in the same directory.
-except ImportError:
-    import sys
-    sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)
-    sys.exit(1)
-
-if __name__ == "__main__":
-    execute_manager(settings)

--- a/madeira/mp3/admin.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-"""
-Automatic admin definitions for the models in the mp3 application.
-
-"""
-from django.contrib import admin
-from django.conf import settings
-
-from mp3.models import Collection, Song
-
-
-class SongInline(admin.TabularInline):
-   model = Song
-
-
-class CollectionAdmin(admin.ModelAdmin):
-    list_filter = ['date_added']
-    list_display = ['title', 'date_added']
-    inlines = [SongInline]
-
-    class Media:
-        js = settings.THIRD_PARTY_JS['tiny_mce']
-
-
-class SongAdmin(admin.ModelAdmin):
-    list_display = ['title', 'collection']
-
-
-admin.site.register(Collection, CollectionAdmin)
-admin.site.register(Song, SongAdmin)

--- a/madeira/mp3/management/commands/import_old_mp3.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,64 +0,0 @@
-"""
-import_old_mp3.py - For importing mp3 data from the older version of this
-website.
-
-"""
-import datetime
-
-from django.core.management.base import LabelCommand
-from django.utils import simplejson as json
-from django.utils.html import linebreaks
-
-from mp3.models import Collection, Song
-
-
-class Command(LabelCommand):
-    args = '<filename filename ...>'
-    help = 'Imports older mp3 & mp3 sets in JSON format'
-
-    collections = {}
-
-    def handle_label(self, filename, **options):
-        """
-        Process the file of older mp3 & mp3 sets in JSON. Convert to the new
-        model scheme.
-
-        """
-        with open(filename, 'rb') as f:
-            items = json.load(f)
-
-        for item in items:
-            if item['model'] == 'band.mp3_set':
-                self.process_mp3_set(item)
-
-        for item in items:
-            if item['model'] == 'band.mp3':
-                self.process_mp3(item)
-
-    def process_mp3_set(self, item):
-
-        fields = item['fields']
-
-        description = linebreaks(fields['text'].strip())
-
-        coll = Collection(
-                id=item['pk'],
-                title=fields['title'].strip(),
-                date_added=datetime.datetime.strptime(fields['date'], '%Y-%m-%d'),
-                description=description)
-
-        coll.save()
-        self.collections[coll.pk] = coll
-
-    def process_mp3(self, item):
-
-        fields = item['fields']
-
-        song = Song(
-                id=item['pk'],
-                title=fields['title'].strip(),
-                description=fields['desc'].strip(),
-                file=fields['file'],
-                collection=self.collections[fields['mp3_set']],
-                )
-        song.save()

--- a/madeira/mp3/models.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,39 +0,0 @@
-"""
-Models for the mp3 application.
-
-"""
-from django.db import models
-
-
-class Collection(models.Model):
-    """
-    This model represents a collection of songs.
-
-    """
-    title = models.CharField(max_length=64)
-    description = models.TextField()
-    date_added = models.DateTimeField()
-
-    class Meta:
-        ordering = ['-date_added']
-
-    def __unicode__(self):
-        return self.title
-
-
-class Song(models.Model):
-    """
-    This model represents an uploaded song file.
-
-    """
-    title = models.CharField(max_length=64)
-    description = models.CharField(max_length=255, blank=True)
-    file = models.FileField(upload_to='mp3s/%Y/%m/%d/')
-    collection = models.ForeignKey(Collection)
-
-    class Meta:
-        ordering = ['title']
-
-    def __unicode__(self):
-        return self.title
-

--- a/madeira/mp3/urls.py	Sat Apr 14 15:49:28 2012 -0500
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-"""
-Urls for the mp3 application.
-
-"""
-from django.conf.urls import patterns, url
-from django.views.generic import ListView
-
-from mp3.models import Collection
-
-
-urlpatterns = patterns('',
-   url(r'^$',
-       ListView.as_view(
-           model=Collection,
-           paginate_by=10,
-           context_object_name='collection_list'),
-       name='mp3-index'),
-)