from django.db import models

from django.contrib.auth.models import User

import reversion

from django import template

from django.core.urlresolvers import reverse

from symposion.boxes.models import Box

from symposion.boxes.forms import BoxForm

from symposion.boxes.authorization import load_can_edit

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.authorization import load_can_edit

from symposion.boxes.forms import BoxForm

from symposion.boxes.models import Box

def get_auth_vars(request):

    auth_vars = {}

    if request.method == "POST":

        keys = [k for k in request.POST.keys() if k.startswith("boxes_auth_")]

        for key in keys:

            auth_vars[key.replace("boxes_auth_", "")] = request.POST.get(key)

from django.contrib import admin

import reversion

from .models import Page

class PageAdmin(reversion.VersionAdmin):

    pass

admin.site.register(Page, PageAdmin)

from datetime import datetime

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

        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)

def generate_filename(instance, filename):

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

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

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

    url(r"^files/$", "file_index", name="file_index"),

from appconf import AppConf

class SymposionAppConf(AppConf):

    VOTE_THRESHOLD = 3

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

    url(r"^users/$", "user_list", name="user_list"),

)

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

import csv

from django.http import HttpResponse

                         fields=None, exclude=None, header=True):

    """

    This function returns an export csv action

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

    'header' is whether or not to output the column names as the first row

    """

            fieldset = set(fields)

            field_names = fieldset

        elif exclude:

            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

    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

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

            "speaker": self.speaker.name,

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

@register.tag

def associated_proposals(parser, token):

    """

    {% associated_proposals as associated_proposals %}

    """

    return AssociatedProposalsNode.handle_token(parser, token)

from django.conf.urls.defaults import *

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

    url(r"^submit/$", "proposal_submit", name="proposal_submit"),

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

                # fire off email letting user know about site and to create

                # account and speaker profile

                send_email(

                    [email_address], "speaker_invite",

                    context=message_ctx

                )

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

            return redirect("proposal_speaker_manage", proposal.pk)

    else:

        add_speaker_form = AddSpeakerForm(proposal=proposal)

    ctx = {

        "proposal": proposal,

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

@login_required

def proposal_pending_join(request, pk):

    proposal = get_object_or_404(ProposalBase, pk=pk)

    if speaking.status == AdditionalSpeaker.SPEAKING_STATUS_PENDING:

        speaking.status = AdditionalSpeaker.SPEAKING_STATUS_ACCEPTED

        speaking.save()

        messages.success(request, "You have accepted the invitation to join %s" % proposal.title)

        return redirect("dashboard")

    else:

        return redirect("dashboard")

@login_required

def proposal_pending_decline(request, pk):

    proposal = get_object_or_404(ProposalBase, pk=pk)

    if speaking.status == AdditionalSpeaker.SPEAKING_STATUS_PENDING:

        speaking.status = AdditionalSpeaker.SPEAKING_STATUS_DECLINED

        speaking.save()

        messages.success(request, "You have declined to speak on %s" % proposal.title)

        return redirect("dashboard")

    else:

from symposion.proposals.models import ProposalSection

def reviews(request):

    sections = []

    for section in ProposalSection.objects.all():

from django.core.management.base import BaseCommand

from symposion.reviews.models import ReviewAssignment

from symposion.proposals.models import ProposalBase

from django.core.management.base import BaseCommand

from symposion.reviews.models import ProposalResult

class Command(BaseCommand):

    def handle(self, *args, **options):

    def handle(self, *args, **options):

        accepted_proposals = ProposalResult.objects.filter(status="accepted")

        accepted_proposals = accepted_proposals.order_by("proposal")

        for result in accepted_proposals:

            promote_proposal(result.proposal)

        else:

            # handle that we've found a latest vote

            # check if self is the lastest vote

            if self == latest:

                # self is the latest review; revert the latest vote to the

                # previous vote

                self.proposal.result.update_vote(self.vote, previous=previous.vote, removal=True)

                lv = LatestVote.objects.filter(proposal=self.proposal, user=self.user)

                lv.update(

                    vote=previous.vote,

                    submitted_at=previous.submitted_at,

                )

    body = models.TextField()

class ResultNotification(models.Model):

    proposal = models.ForeignKey("proposals.ProposalBase", related_name="notifications")

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

    to_address = models.EmailField()

    from_address = models.EmailField()

    subject = models.CharField(max_length=100)

    body = models.TextField()

from django import template

register = template.Library()

@register.assignment_tag(takes_context=True)

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

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

    url(r"^section/(?P<section_slug>[\w\-]+)/all/$", "review_section", {"reviewed": "all"}, name="review_section"),

    url(r"^section/(?P<section_slug>[\w\-]+)/reviewed/$", "review_section", {"reviewed": "reviewed"}, name="user_reviewed"),

    proposal.  If ``reviewer`` is ``True`` the speaker can be a part of the

    reviewer group.

    """

    if user.is_superuser:

        return True

    if speaker:

            return True

    if reviewer:

        if user.groups.filter(name="reviewers").exists():

            return True

    return False

from django.core.mail import send_mass_mail

from django.db.models import Q

from django.http import HttpResponseBadRequest, HttpResponseNotAllowed

from django.shortcuts import render, redirect, get_object_or_404

from django.template import Context, Template

from django.views.decorators.http import require_POST

            obj.user_vote = None

            obj.user_vote_css = "no-vote"

        yield obj

@login_required

def review_section(request, section_slug, assigned=False, reviewed="all"):

    if not request.user.has_perm("reviews.can_review_%s" % section_slug):

        return access_not_permitted(request)

    section = get_object_or_404(ProposalSection, section__slug=section_slug)

    queryset = ProposalBase.objects.filter(kind__section=section)

    if assigned:

        queryset = queryset.filter(id__in=assignments)

    # passing reviewed in from reviews.urls and out to review_list for

    # appropriate template header rendering

    if reviewed == "all":

        queryset = queryset.select_related("result").select_subclasses()

        "section": section,

        "reviewed": reviewed,

    }

    return render(request, "reviews/review_list.html", ctx)

@login_required

def review_list(request, section_slug, user_pk):

    # if they're not a reviewer admin and they aren't the person whose

    # review list is being asked for, don't let them in

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

    queryset = ProposalBase.objects.select_related("speaker__user", "result").select_subclasses()

    if section_slug:

        queryset = queryset.filter(kind__section__slug=section_slug)

    proposals = {

        # proposals with fewer than VOTE_THRESHOLD reviews

    }

    admin = request.user.has_perm("reviews.can_manage_%s" % section_slug)

    for status in proposals:

        if key and key != status:

            continue

    if key:

        ctx.update({

            "key": key,

            "proposals": proposals[key],

        })

    })

@login_required

@require_POST

def review_assignment_opt_out(request, pk):

    if not review_assignment.opted_out:

        review_assignment.opted_out = True

        review_assignment.save()

    return redirect("review_assignments")

@login_required

def review_bulk_accept(request, section_slug):

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

@login_required

def result_notification(request, section_slug, status):

    if not request.user.has_perm("reviews.can_manage_%s" % section_slug):

        return access_not_permitted(request)

    notification_templates = NotificationTemplate.objects.all()

    ctx = {

        "section_slug": section_slug,

        "status": status,

        "proposals": proposals,

from django.core.exceptions import ObjectDoesNotExist

from django.db import models

from markitup.fields import MarkupField

from symposion.proposals.models import ProposalBase

from symposion.conference.models import Section

class Schedule(models.Model):

    slot = models.OneToOneField(Slot, null=True, blank=True, related_name="content_ptr")

    title = models.CharField(max_length=100)

    description = MarkupField()

    abstract = MarkupField()

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

    cancelled = models.BooleanField(default=False)

    proposal_base = models.OneToOneField(ProposalBase, related_name="presentation")

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

    @property

    def number(self):

import itertools

from django.db.models import Count, Min

from symposion.schedule.models import Room, Slot, SlotRoom

        qs = qs.filter(day=self.day)

        return qs

    def rooms(self):

        qs = Room.objects.all()

        qs = qs.filter(schedule=self.day.schedule)

        qs = qs.order_by("order")

        return qs

    def __iter__(self):

        times = sorted(set(itertools.chain(*self.slots_qs().values_list("start", "end"))))

        slots = Slot.objects.filter(pk__in=self.slots_qs().values("pk"))

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

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

    url(r"^$", "schedule_conference", name="schedule_conference"),

    url(r"^edit/$", "schedule_edit", name="schedule_edit"),

from django.http import Http404, HttpResponse

from django.shortcuts import render, get_object_or_404, redirect

from django.template import loader, Context

from django.contrib.auth.decorators import login_required

from symposion.speakers.models import Speaker

admin.site.register(Speaker,

                    list_display=["name", "email", "created"],

        name="Guido van Rossum",

        biography="I wrote Python, and named it after Monty Python",

    )

    Speaker.objects.create(

        user=matz,

        name="Yukihiro Matsumoto",

    )

    Speaker.objects.create(

        user=larry,

        name="Larry Wall",

        biography="I wrote Perl, and named it after the Parable of the Pearl",

    )

import csv

import os

from symposion.speakers.models import Speaker

class Command(BaseCommand):

    SESSION_COUNT_CHOICES = [

        (1, "One"),

        (2, "Two")

    ]

    user = models.OneToOneField(User, null=True, related_name="speaker_profile")

    photo = models.ImageField(upload_to="speaker_photos", blank=True)

    annotation = models.TextField()  # staff only

    invite_email = models.CharField(max_length=200, unique=True, null=True, db_index=True)

    invite_token = models.CharField(max_length=40, db_index=True)

    created = models.DateTimeField(

        default=datetime.datetime.now,

    def __unicode__(self):

        if self.user:

            return self.name

        else:

            return "?"

    def get_absolute_url(self):

        return reverse("speaker_edit")

    @property

    def email(self):

        if self.user is not None:

from django.conf.urls.defaults import *

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

    url(r"^create/$", "speaker_create", name="speaker_create"),

    url(r"^create/(\w+)/$", "speaker_create_token", name="speaker_create_token"),

            additional_speakers = ProposalBase.additional_speakers.through

            additional_speakers._default_manager.filter(

                speaker=speaker

            ).update(

                speaker=existing_speaker

            )

            return redirect("dashboard")

    else:

        if not request.user.is_authenticated():

            return redirect("account_login")

    return redirect("speaker_create")

from django.contrib import admin

class BenefitLevelInline(admin.TabularInline):

    model = BenefitLevel

    extra = 0

from django.core.management.base import BaseCommand

class Command(BaseCommand):

    def handle(self, *args, **options):

        for sponsor in Sponsor.objects.all():