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:

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:

from django import template

from django.core.urlresolvers import reverse

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

    request = context["request"]

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

    try:

        box = None

    if can_edit and show_edit:

        form_action = None

    return {

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

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

def get_auth_vars(request):

def box_edit(request, label):

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

        return HttpResponseForbidden()

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

    try:

        box = None

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

class PageAdmin(reversion.VersionAdmin):

class PageForm(forms.ModelForm):

    class Meta:

class FileUploadForm(forms.Form):

    file = forms.FileField()

class PublishedPageManager(models.Manager):

    def get_query_set(self):

class Page(models.Model):

    STATUS_CHOICES = (

    )

    title = models.CharField(max_length=100)

    tags = TaggableManager(blank=True)

    published = PublishedPageManager()

    def __unicode__(self):

        return self.title

    @models.permalink

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

    @property

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

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

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

    def clean_fields(self, exclude=None):

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

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

def page(request, path):

    try:

        page = None

    editable = can_edit(page, request.user)

    if page is None:

            raise Http404

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

def page_edit(request, path):

    try:

        page = None

    if not can_edit(page, request.user):

        raise Http404

    if request.method == "POST":

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

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

        raise Http404

    ctx = {

        raise Http404

    if request.method == "POST":

        form = FileUploadForm()

    ctx = {

    file = get_object_or_404(File, pk=pk)

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

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

    return response

        raise Http404

    file = get_object_or_404(File, pk=pk)

from appconf import AppConf

class SymposionAppConf(AppConf):

    VOTE_THRESHOLD = 3

    Section,

)

    """

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

    # when the conference runs

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

            del CONFERENCE_CACHE[self.id]

    def delete(self):

            pass

    class Meta(object):

    """

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

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

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

    def __unicode__(self):

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

    class Meta(object):

def user_list(request):

    if not request.user.is_staff:

        raise Http404()

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

class SignupForm(account.forms.SignupForm):

    first_name = forms.CharField()

        ]

    def clean_email_confirm(self):

            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

    """

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

        writer = csv.writer(response)

        for obj in queryset:

        return response

class AddSpeakerForm(forms.Form):

    email = forms.EmailField(

    )

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

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

    def clean_email(self):

class SupportingDocumentCreateForm(forms.ModelForm):

    class Meta:

    configuration of proposal submissions for a specific Section.

    a section is available for proposals iff:

    """

    section = models.OneToOneField(Section)

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

    published = models.NullBooleanField()

    @classmethod

        )

    def is_available(self):

        return True

    def __unicode__(self):

    e.g. talk vs panel vs tutorial vs poster

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

    """

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

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

    slug = models.SlugField()

    def __unicode__(self):

class ProposalBase(models.Model):

    objects = InheritanceManager()

    kind = models.ForeignKey(ProposalKind)

    title = models.CharField(max_length=100)

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

    )

        _("Detailed Abstract"),

    )

        blank=True,

    )

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

    cancelled = models.BooleanField(default=False)

    def can_edit(self):

        return True

    @property

        return self.kind.section

    @property

        return self.speaker.email

    @property

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

    def speakers(self):

        yield self.speaker

            yield speaker

    def notification_email_context(self):

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    SPEAKING_STATUS_DECLINED = 3

    SPEAKING_STATUS = [

    ]

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

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

    class Meta:

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)

    def download_url(self):

class AssociatedProposalsNode(template.Node):

    @classmethod

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

    def __init__(self, context_var):

        self.context_var = context_var

    def render(self, context):

class PendingProposalsNode(template.Node):

    @classmethod

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

    def __init__(self, context_var):

        self.context_var = context_var

    def render(self, context):

    return AssociatedProposalsNode.handle_token(parser, token)

from django.conf.urls.defaults import *

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

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

            return redirect("dashboard")

    kinds = []

            kinds.append(kind)

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

def proposal_submit_kind(request, kind_slug):

    kind = get_object_or_404(ProposalKind, slug=kind_slug)

    if not request.user.is_authenticated():

            return redirect("dashboard")

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

        return redirect("proposal_submit")

    form_class = get_form(settings.PROPOSAL_FORMS[kind_slug])

    if request.method == "POST":

        form = form_class()

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

    proposal = ProposalBase.objects.get_subclass(pk=proposal.pk)

    if proposal.speaker != request.user.speaker_profile:

        raise Http404()

    if request.method == "POST":

            }

            def create_speaker_token(email_address):

                        [email_address], "speaker_no_profile",

                    )

                        [email_address], "speaker_addition",

                    )

                    [email_address], "speaker_invite",

                )

            messages.success(request, "Speaker invited to proposal.")

        raise Http404()

    if not proposal.can_edit():

        return render(request, "proposals/proposal_error.html", ctx)

    form_class = get_form(settings.PROPOSAL_FORMS[proposal.kind.slug])

        form = form_class(instance=proposal)

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

    proposal = ProposalBase.objects.get_subclass(pk=proposal.pk)

    if request.user not in [p.user for p in proposal.speakers()]:

        raise Http404()

    if "symposion.reviews" in settings.INSTALLED_APPS:

            if message_form.is_valid():

                message = message_form.save(commit=False)

                message.save()

                ProposalMessage = SpeakerCommentForm.Meta.model

                )

                for reviewer in reviewers:

                    )

                return redirect(request.path)

        message_form = None

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

    proposal = ProposalBase.objects.get_subclass(pk=proposal.pk)

    if proposal.speaker.user != request.user:

        return redirect("dashboard")

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

    proposal = get_object_or_404(ProposalBase, pk=pk)

    if speaking.status == AdditionalSpeaker.SPEAKING_STATUS_PENDING:

    proposal = get_object_or_404(ProposalBase, pk=pk)

    if speaking.status == AdditionalSpeaker.SPEAKING_STATUS_PENDING:

    proposal = ProposalBase.objects.get_subclass(pk=proposal.pk)

    if proposal.cancelled:

        return HttpResponseForbidden()

    if request.method == "POST":

        form = SupportingDocumentCreateForm()

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

    proposal_pk = document.proposal.pk