def load_can_edit():

    import_path = getattr(settings, "BOXES_CAN_EDIT_CALLABLE", None)

    if import_path is None:

        return default_can_edit

    return load_path_attr(import_path)

class BoxForm(forms.ModelForm):

    class Meta:

        model = Box

        fields = ["content"]

from django.db import models

from django.contrib.auth.models import User

class Box(models.Model):

    label = models.CharField(max_length=100, db_index=True)

    content = MarkupField(blank=True)

    created_by = models.ForeignKey(User, related_name="boxes")

    last_updated_by = models.ForeignKey(User, related_name="updated_boxes")

    def __unicode__(self):

        return self.label

    class Meta:

        verbose_name_plural = "boxes"

from django import template

from django.core.urlresolvers import reverse

from symposion.boxes.models import Box

from symposion.boxes.forms import BoxForm

@register.inclusion_tag("boxes/box.html", takes_context=True)

def box(context, label, show_edit=True, *args, **kwargs):

    request = context["request"]

    can_edit = load_can_edit()(request, *args, **kwargs)

    try:

        box = Box.objects.get(label=label)

    except Box.DoesNotExist:

        box = None

    if can_edit and show_edit:

        form = BoxForm(instance=box, prefix=label)

        form_action = reverse("box_edit", args=[label])

    else:

        form = None

        form_action = None

    return {

        "request": request,

        "label": label,

from django.conf.urls.defaults import url, patterns

urlpatterns = patterns("symposion.boxes.views",

    url(r"^([-\w]+)/edit/$", "box_edit", name="box_edit"),

from symposion.boxes.models import Box

def get_auth_vars(request):

    auth_vars = {}

    if request.method == "POST":

@require_POST

def box_edit(request, label):

    if not load_can_edit()(request, **get_auth_vars(request)):

        return HttpResponseForbidden()

    next = request.GET.get("next")

    try:

        box = Box.objects.get(label=label)

    except Box.DoesNotExist:

        box = None

    form = BoxForm(request.POST, instance=box, prefix=label)

    if form.is_valid():

from .models import Page

class PageAdmin(reversion.VersionAdmin):

    pass

class PageForm(forms.ModelForm):

    class Meta:

        model = Page

        fields = ["title", "body", "path"]

class FileUploadForm(forms.Form):

    file = forms.FileField()

from django.db import models

class PublishedPageManager(models.Manager):

    def get_query_set(self):

        qs = super(PublishedPageManager, self).get_query_set()

        return qs.filter(publish_date__lte=datetime.now())

class Page(models.Model):

    STATUS_CHOICES = (

        (1, _("Draft")),

        (2, _("Public")),

    )

    title = models.CharField(max_length=100)

    path = models.CharField(max_length=100, unique=True)

    body = MarkupField()

    created = models.DateTimeField(editable=False, default=datetime.datetime.now)

    updated = models.DateTimeField(editable=False, default=datetime.datetime.now)

    tags = TaggableManager(blank=True)

    published = PublishedPageManager()

    def __unicode__(self):

        return self.title

    @models.permalink

    def get_absolute_url(self):

        return ("cms_page", [self.path])

    @property

    def is_community(self):

        return self.path.lower().startswith("community/")

    def save(self, *args, **kwargs):

        self.updated = datetime.datetime.now()

        super(Page, self).save(*args, **kwargs)

    def clean_fields(self, exclude=None):

        super(Page, self).clean_fields(exclude)

        if not re.match(settings.SYMPOSION_PAGE_REGEX, self.path):

reversion.register(Page)

class File(models.Model):

    file = models.FileField(upload_to=generate_filename)

    created = models.DateTimeField(default=datetime.datetime.now)

    def download_url(self):

        return reverse("file_download", args=[self.pk, os.path.basename(self.file.name).lower()])

from django.conf.urls.defaults import url, patterns

PAGE_RE = r"(([\w-]{1,})(/[\w-]{1,})*)/"

def page(request, path):

    try:

        page = Page.published.get(path=path)

    except Page.DoesNotExist:

        page = None

    editable = can_edit(page, request.user)

    if page is None:

        if editable:

            return redirect("cms_page_edit", path=path)

        else:

            raise Http404

    return render(request, "cms/page_detail.html", {

        "page": page,

        "editable": editable,

@login_required

def page_edit(request, path):

    try:

        page = Page.published.get(path=path)

    except Page.DoesNotExist:

        page = None

    if not can_edit(page, request.user):

        raise Http404

    if request.method == "POST":

        form = PageForm(request.POST, instance=page)

        if form.is_valid():

            print form.errors

    else:

        form = PageForm(instance=page, initial={"path": path})

    return render(request, "cms/page_edit.html", {

        "path": path,

        "form": form

def file_index(request):

    if not can_upload(request.user):

        raise Http404

    ctx = {

        "files": File.objects.all(),

    }

def file_create(request):

    if not can_upload(request.user):

        raise Http404

    if request.method == "POST":

        form = FileUploadForm(request.POST, request.FILES)

        if form.is_valid():

            return redirect("file_index")

    else:

        form = FileUploadForm()

    ctx = {

        "form": form,

    }

def file_download(request, pk, *args):

    file = get_object_or_404(File, pk=pk)

    if getattr(settings, "USE_X_ACCEL_REDIRECT", False):

        response = HttpResponse()

        response["X-Accel-Redirect"] = file.file.url

        del response["content-type"]

    else:

        response = static.serve(request, file.file.name, document_root=settings.MEDIA_ROOT)

    return response

def file_delete(request, pk):

    if not can_upload(request.user):

        raise Http404

    file = get_object_or_404(File, pk=pk)

    if request.method == "POST":

        file.delete()

from appconf import AppConf

class SymposionAppConf(AppConf):

    VOTE_THRESHOLD = 3

admin.site.register(Conference, list_display=("title", "start_date", "end_date"))

admin.site.register(

    Section,

)

    """

    the full conference for a specific year, e.g. US PyCon 2012.

    """

    title = models.CharField(_("title"), max_length=100)

    # when the conference runs

    start_date = models.DateField(_("start date"), null=True, blank=True)

    end_date = models.DateField(_("end date"), null=True, blank=True)

    # timezone the conference is in

    timezone = TimeZoneField(_("timezone"), blank=True)

    def __unicode__(self):

        return self.title

    def save(self, *args, **kwargs):

        super(Conference, self).save(*args, **kwargs)

        if self.id in CONFERENCE_CACHE:

            del CONFERENCE_CACHE[self.id]

    def delete(self):

        pk = self.pk

        super(Conference, self).delete()

            del CONFERENCE_CACHE[pk]

        except KeyError:

            pass

    class Meta(object):

        verbose_name = _("conference")

        verbose_name_plural = _("conferences")

    "Talks", "Expo", "Sprints", that may have its own review and

    scheduling process.

    """

    conference = models.ForeignKey(Conference, verbose_name=_("conference"))

    name = models.CharField(_("name"), max_length=100)

    slug = models.SlugField()

    # when the section runs

    start_date = models.DateField(_("start date"), null=True, blank=True)

    end_date = models.DateField(_("end date"), null=True, blank=True)

    def __unicode__(self):

        return "%s %s" % (self.conference, self.name)

    class Meta(object):

        verbose_name = _("section")

        verbose_name_plural = _("sections")

urlpatterns = patterns("symposion.conference.views",

@login_required

def user_list(request):

    if not request.user.is_staff:

        raise Http404()

    return render(request, "conference/user_list.html", {

        "users": User.objects.all(),

    })

class SignupForm(account.forms.SignupForm):

    first_name = forms.CharField()

    last_name = forms.CharField()

    email_confirm = forms.EmailField(label="Confirm Email")

            "password",

            "password_confirm"

        ]

    def clean_email_confirm(self):

        email = self.cleaned_data.get("email")

        email_confirm = self.cleaned_data["email_confirm"]

        if email:

            if email != email_confirm:

        return email_confirm

from html5lib import html5parser, sanitizer

import markdown

def parse(text):

    # First run through the Markdown parser

    text = markdown.markdown(text, extensions=["extra"], safe_mode=False)

    # Sanitize using html5lib

    bits = []

    parser = html5parser.HTMLParser(tokenizer=sanitizer.HTMLSanitizer)

from django.http import HttpResponse

    """

    This function returns an export csv action

    'fields' and 'exclude' work like in Django ModelForm

            excludeset = set(exclude)

            field_names = field_names - excludeset

        response = HttpResponse(mimetype="text/csv")

        writer = csv.writer(response)

        if header:

            writer.writerow(list(field_names))

        for obj in queryset:

        return response

    export_as_csv.short_description = description

    return export_as_csv

class AddSpeakerForm(forms.Form):

    email = forms.EmailField(

        label="Email address of new speaker (use their email address, not yours)"

    )

    def __init__(self, *args, **kwargs):

        self.proposal = kwargs.pop("proposal")

        super(AddSpeakerForm, self).__init__(*args, **kwargs)

    def clean_email(self):

        value = self.cleaned_data["email"]

        exists = self.proposal.additional_speakers.filter(

class SupportingDocumentCreateForm(forms.ModelForm):

    class Meta:

        model = SupportingDocument

        fields = [

class ProposalSection(models.Model):

    """

    configuration of proposal submissions for a specific Section.

    a section is available for proposals iff:

      * it is after start (if there is one) and

      * it is before end (if there is one) and

      * closed is NULL or False

    """

    section = models.OneToOneField(Section)

    start = models.DateTimeField(null=True, blank=True)

    end = models.DateTimeField(null=True, blank=True)

    closed = models.NullBooleanField()

    published = models.NullBooleanField()

    @classmethod

    def available(cls):

        now = datetime.datetime.now()

            Q(end__gt=now) | Q(end=None),

            Q(closed=False) | Q(closed=None),

        )

    def is_available(self):

        if self.closed:

            return False

        if self.end and self.end < now:

            return False

        return True

    def __unicode__(self):

        return self.section.name

class ProposalKind(models.Model):

    """

    e.g. talk vs panel vs tutorial vs poster

    Note that if you have different deadlines, reviewers, etc. you'll want

    to distinguish the section as well as the kind.

    """

    section = models.ForeignKey(Section, related_name="proposal_kinds")

    name = models.CharField(_("Name"), max_length=100)

    slug = models.SlugField()

    def __unicode__(self):

        return self.name

class ProposalBase(models.Model):

    objects = InheritanceManager()

    kind = models.ForeignKey(ProposalKind)

    title = models.CharField(max_length=100)

    description = models.TextField(

        _("Brief Description"),

        max_length=400,  # @@@ need to enforce 400 in UI

    )

    abstract = MarkupField(

        _("Detailed Abstract"),

    )

    additional_notes = MarkupField(

        blank=True,

    )

    submitted = models.DateTimeField(

        default=datetime.datetime.now,

        editable=False,

    )

    speaker = models.ForeignKey("speakers.Speaker", related_name="proposals")

    cancelled = models.BooleanField(default=False)

    def can_edit(self):

        return True

    @property

    def section(self):

        return self.kind.section

    @property

    def speaker_email(self):

        return self.speaker.email

    @property

    def number(self):

        return str(self.pk).zfill(3)

    def speakers(self):

        yield self.speaker

            yield speaker

    def notification_email_context(self):

        return {

            "title": self.title,

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    SPEAKING_STATUS_ACCEPTED = 2

    SPEAKING_STATUS_DECLINED = 3

    SPEAKING_STATUS = [

        (SPEAKING_STATUS_PENDING, _("Pending")),

        (SPEAKING_STATUS_ACCEPTED, _("Accepted")),

        (SPEAKING_STATUS_DECLINED, _("Declined")),

    ]

    speaker = models.ForeignKey("speakers.Speaker")

    proposalbase = models.ForeignKey(ProposalBase)

    status = models.IntegerField(choices=SPEAKING_STATUS, default=SPEAKING_STATUS_PENDING)

    class Meta:

        db_table = "proposals_proposalbase_additional_speakers"

        unique_together = ("speaker", "proposalbase")

class SupportingDocument(models.Model):

    proposal = models.ForeignKey(ProposalBase, related_name="supporting_documents")

    uploaded_by = models.ForeignKey(User)

    created_at = models.DateTimeField(default=datetime.datetime.now)

    file = models.FileField(upload_to=uuid_filename)

    description = models.CharField(max_length=140)

    def download_url(self):

class AssociatedProposalsNode(template.Node):