from django.db import models

from django.contrib.auth.models import User

import reversion

from markitup.fields import MarkupField

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

register = template.Library()

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

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

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

)

from django.shortcuts import redirect

from django.views.decorators.http import require_POST

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)

        auth_vars["user"] = request.user

    return auth_vars

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

    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)

def generate_filename(instance, filename):

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

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

    url(r"^files/(\d+)/([^/]+)$", "file_download", name="file_download"),

from appconf import AppConf

class SymposionAppConf(AppConf):

    VOTE_THRESHOLD = 3

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

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

)

            "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

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

    """

    def export_as_csv(modeladmin, request, queryset):

        """

        opts = modeladmin.model._meta

        if fields:

            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

    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

        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,

            "speaker": self.speaker.name,

            "kind": self.kind.name,

        }

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

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

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

    url(r"^(\d+)/edit/$", "proposal_edit", name="proposal_edit"),

                speaker, token = create_speaker_token(email_address)

                message_ctx["token"] = token

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

        "speakers": proposal.speakers(),

        "add_speaker_form": add_speaker_form,

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

        return redirect("dashboard")

from symposion.proposals.models import ProposalSection

def reviews(request):

    sections = []

    for section in ProposalSection.objects.all():

        if request.user.has_perm("reviews.can_review_%s" % section.section.slug):

            sections.append(section)

from django.core.management.base import BaseCommand

from symposion.reviews.models import ReviewAssignment

from symposion.proposals.models import ProposalBase

class Command(BaseCommand):

from django.core.management.base import BaseCommand

from symposion.reviews.models import ProposalResult

class Command(BaseCommand):

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

        ProposalResult.full_calculate()

class Command(BaseCommand):

    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)

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

            lv.delete()

        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,

                )

            else:

                # self is not the latest review so we just need to decrement

    from_address = models.EmailField()

    subject = models.CharField(max_length=100)

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

    @property

    def email_args(self):

from django import template

register = template.Library()

@register.assignment_tag(takes_context=True)

def review_assignments(context):

    request = context["request"]

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

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

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

    If ``speaker`` is ``True`` then the user can be one of the speakers for the

    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

from django.contrib.auth.decorators import login_required

            obj.user_vote_css = LatestVote.objects.get(**lookup_params).css_class()

        except LatestVote.DoesNotExist:

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

        reviewed = "all_reviews"

    elif reviewed == "reviewed":

    ctx = {

        "proposals": proposals,

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

        if not request.user.pk == user_pk:

            return access_not_permitted(request)

        "vote_threshold": VOTE_THRESHOLD,

    }

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

        })

    else:

        ctx["proposals"] = proposals

    return render(request, "reviews/review_assignment.html", {

        "assignments": assignments,

    })

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

        return access_not_permitted(request)

    if request.method == "POST":

    })

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

        "notification_templates": notification_templates,

    }

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

    section = models.OneToOneField(Section)

class Presentation(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):

        return self.proposal.number

import itertools

from django.db.models import Count, Min

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

class TimeTable(object):

    def slots_qs(self):

        qs = Slot.objects.all()

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

        slots = slots.annotate(room_count=Count("slotroom"), order=Min("slotroom__room__order"))

        slots = slots.order_by("start", "order")

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

    url(r"^list/$", "schedule_list", name="schedule_list"),

    url(r"^presentations.csv$", "schedule_list_csv", name="schedule_list_csv"),

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.schedule.forms import SlotEditForm

from symposion.schedule.models import Schedule, Day, Slot, Presentation

from django.contrib import admin

from symposion.speakers.models import Speaker

admin.site.register(Speaker,

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

    Speaker.objects.create(

        user=guido,

        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