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

from django.db import models

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

@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 = None

        form_action = None

    return {

        "request": request,

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

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

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

def get_auth_vars(request):

    auth_vars = {}

@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)

from .models import Page

class PageAdmin(reversion.VersionAdmin):

class PageForm(forms.ModelForm):

    class Meta:

        model = Page

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()

class Page(models.Model):

    STATUS_CHOICES = (

        (1, _("Draft")),

        (2, _("Public")),

    )

    title = models.CharField(max_length=100)

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

    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):

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

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:

        else:

            raise Http404

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

        "page": page,

@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)

    else:

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

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

        "path": path,

    if not can_upload(request.user):

        raise Http404

    ctx = {

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

    if not can_upload(request.user):

        raise Http404

    if request.method == "POST":

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

    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()

    else:

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

    return response

    if not can_upload(request.user):

        raise Http404

    file = get_object_or_404(File, pk=pk)

    if request.method == "POST":

from appconf import AppConf

class SymposionAppConf(AppConf):

    VOTE_THRESHOLD = 3

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

        except KeyError:

            pass

    class Meta(object):

        verbose_name = _("conference")

    scheduling process.

    """

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

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

    slug = models.SlugField()

    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")

@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()

            "password_confirm"

        ]

    def clean_email_confirm(self):

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

        if email:

            if email != email_confirm:

        return email_confirm

from html5lib import html5parser, sanitizer

def parse(text):

    # First run through the Markdown parser

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

    # Sanitize using html5lib

    bits = []

    """

    This function returns an export csv action

            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

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"]

class SupportingDocumentCreateForm(forms.ModelForm):

    class Meta:

        model = SupportingDocument

    """

    configuration of proposal submissions for a specific Section.

    a section is available for proposals iff:

      * it is after start (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):

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

        )

    def is_available(self):

        if self.closed:

            return False

        return True

    def __unicode__(self):

        return self.section.name

    """

    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(

    )

    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 {

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    SPEAKING_STATUS_ACCEPTED = 2

    SPEAKING_STATUS_DECLINED = 3

    SPEAKING_STATUS = [

        (SPEAKING_STATUS_PENDING, _("Pending")),

        (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"

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):

    @classmethod

    def handle_token(cls, parser, token):

        else:

            raise template.TemplateSyntaxError("%r takes 'as var'" % bits[0])

    def __init__(self, context_var):

        self.context_var = context_var

    def render(self, context):

        request = context["request"]

class PendingProposalsNode(template.Node):

    @classmethod

    def handle_token(cls, parser, token):

        else:

            raise template.TemplateSyntaxError("%r takes 'as var'" % bits[0])

    def __init__(self, context_var):

        self.context_var = context_var

    def render(self, context):

        request = context["request"]

    """

    return AssociatedProposalsNode.handle_token(parser, token)

from django.conf.urls.defaults import *

    url(r"^(\d+)/join/$", "proposal_pending_join", name="proposal_pending_join"),

    url(r"^(\d+)/decline/$", "proposal_pending_decline", name="proposal_pending_decline"),

    url(r"^(\d+)/document/create/$", "document_create", name="proposal_document_create"),

    url(r"^document/(\d+)/delete/$", "document_delete", name="proposal_document_delete"),

        except ObjectDoesNotExist:

            return redirect("dashboard")

    kinds = []

    for proposal_section in ProposalSection.available():

        for kind in proposal_section.section.proposal_kinds.all():

            kinds.append(kind)

    return render(request, "proposals/proposal_submit.html", {

        "kinds": kinds,

def proposal_submit_kind(request, kind_slug):

    kind = get_object_or_404(ProposalKind, slug=kind_slug)

    if not request.user.is_authenticated():

        return redirect("home")  # @@@ unauth'd speaker info page?

        except ObjectDoesNotExist:

            return redirect("dashboard")

    if not kind.section.proposalsection.is_available():

        return redirect("proposal_submit")