from django.db import models

from django.contrib.auth.models import User

import reversion

from markitup.fields import MarkupField

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

        return self.label

    class Meta:

        verbose_name_plural = "boxes"

import re

from django.conf import settings

from django.core.urlresolvers import reverse

from django.core.exceptions import ValidationError

from django.db import models

from django.utils.translation import ugettext_lazy as _

from markitup.fields import MarkupField

from taggit.managers import TaggableManager

import reversion

from .managers import PublishedPageManager

class Page(models.Model):

    STATUS_CHOICES = (

        (1, _("Draft")),

        (2, _("Public")),

    )

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

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

    tags = TaggableManager(blank=True)

    published = PublishedPageManager()

        return self.title

    @models.permalink

    def get_absolute_url(self):

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

from django.apps import AppConfig

class ConferenceConfig(AppConfig):

    name = "symposion.conference"

    label = "symposion_conference"

from django.db import models

from django.utils.translation import ugettext_lazy as _

from timezones.fields import TimeZoneField

CONFERENCE_CACHE = {}

class Conference(models.Model):

    """

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

    """

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

    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)

        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]

    class Meta(object):

        verbose_name = _("conference")

        verbose_name_plural = _("conferences")

class Section(models.Model):

    """

    a section of the conference such as "Tutorials", "Workshops",

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

    scheduling process.

    """

    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)

    class Meta(object):

        verbose_name = _("section")

        verbose_name_plural = _("sections")

        ordering = ["start_date"]

from html5lib import html5parser, sanitizer

import markdown

def parse(text):

import csv

from django.http import HttpResponse

def export_as_csv_action(description="Export selected objects as CSV file",

from django.apps import AppConfig

class ProposalsConfig(AppConfig):

    name = "symposion.proposals"

    label = "symposion_proposals"

from django import forms

from django.db.models import Q

from symposion.proposals.models import SupportingDocument

# from markitup.widgets import MarkItUpWidget

import os

import uuid

from django.core.urlresolvers import reverse

from django.db import models

from django.db.models import Q

from django.utils.translation import ugettext_lazy as _

from django.utils.timezone import now

from django.contrib.auth.models import User

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from model_utils.managers import InheritanceManager

from symposion.conference.models import Section

from symposion.speakers.models import Speaker

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

        if self.start and self.start > now():

            return False

        if self.end and self.end < now():

            return False

        return True

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

        return self.name

class ProposalBase(models.Model):

    objects = InheritanceManager()

    kind = models.ForeignKey(ProposalKind)

            "title": self.title,

            "speaker": self.speaker.name,

            "speakers": ', '.join([x.name for x in self.speakers()]),

            "kind": self.kind.name,

        }

reversion.register(ProposalBase)

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    SPEAKING_STATUS_ACCEPTED = 2

    SPEAKING_STATUS_DECLINED = 3

    proposalbase = models.ForeignKey(ProposalBase)

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

    class Meta:

        unique_together = ("speaker", "proposalbase")

        if self.status is self.SPEAKING_STATUS_PENDING:

            return _(u"pending speaker (%s)") % self.speaker.email

        elif self.status is self.SPEAKING_STATUS_DECLINED:

            return _(u"declined speaker (%s)") % self.speaker.email

        else:

            return self.speaker.name

import hashlib

import random

import sys

from django.conf import settings

from django.core.exceptions import ObjectDoesNotExist

from django.apps import AppConfig

class ReviewsConfig(AppConfig):

    name = "symposion.reviews"

    label = "symposion_reviews"

from django import forms

from markitup.widgets import MarkItUpWidget

from symposion.reviews.models import Review, Comment, ProposalMessage, VOTES

# -*- coding: utf-8 -*-

from datetime import datetime

from decimal import Decimal

from django.db import models

from django.db.models import Q

from django.db.models.signals import post_save

        return self

class Votes(object):

    PLUS_ONE = "+1"

    PLUS_ZERO = "+0"

    CHOICES = [

        (PLUS_ONE, u"+1 — Good proposal and I will argue for it to be accepted."),

        (PLUS_ZERO, u"+0 — OK proposal, but I will not argue for it to be accepted."),

        (MINUS_ZERO, u"−0 — Weak proposal, but I will not argue strongly against acceptance."),

        (MINUS_ONE, u"−1 — Serious issues and I will argue to reject this proposal."),

def has_permission(user, proposal, speaker=False, reviewer=False):

    """

    Returns whether or not ther user has permission to review this proposal,

    with the specified requirements.

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

from django.contrib import admin

from symposion.schedule.models import Schedule, Day, Room, SlotKind, Slot, SlotRoom, Presentation, Session, SessionRole

class DayInline(admin.StackedInline):

from django.apps import AppConfig

class ScheduleConfig(AppConfig):

    name = "symposion.schedule"

    label = "symposion_schedule"

import csv

import time

from datetime import datetime

from django import forms

"""

This file contains functions that are useful to humans at the shell for

manipulating the database in more natural ways.

"""

from django.db import transaction

from .models import Schedule, Day, Room, Slot, SlotKind, SlotRoom

@transaction.commit_on_success

import datetime

from django.core.exceptions import ObjectDoesNotExist

from django.contrib.auth.models import User

from django.db import models

from markitup.fields import MarkupField

from symposion.proposals.models import ProposalBase

from symposion.conference.models import Section

from symposion.speakers.models import Speaker

class Schedule(models.Model):

    section = models.OneToOneField(Section)

    published = models.BooleanField(default=True)

    hidden = models.BooleanField("Hide schedule from overall conference view", default=False)

    class Meta:

        ordering = ["section"]

class Day(models.Model):

    schedule = models.ForeignKey(Schedule)

    date = models.DateField()

    class Meta:

        unique_together = [("schedule", "date")]

        ordering = ["date"]

class Room(models.Model):

    schedule = models.ForeignKey(Schedule)

    name = models.CharField(max_length=65)

    order = models.PositiveIntegerField()

        return self.name

class SlotKind(models.Model):

    """

    A slot kind represents what kind a slot is. For example, a slot can be a

    break, lunch, or X-minute talk.

    """

    schedule = models.ForeignKey(Schedule)

    label = models.CharField(max_length=50)

        return self.label

class Slot(models.Model):

    day = models.ForeignKey(Day)

    kind = models.ForeignKey(SlotKind)

    start = models.TimeField()

    end = models.TimeField()

            (self.end_datetime - self.start_datetime).total_seconds() / 60)

    @property

    def rooms(self):

        return Room.objects.filter(pk__in=self.slotroom_set.values("room"))

        roomlist = ' '.join(map(lambda r: r.__unicode__(), self.rooms))

    class Meta:

        ordering = ["day", "start", "end"]

class SlotRoom(models.Model):

    """

    Links a slot with a room.

    """

    slot = models.ForeignKey(Slot)

    room = models.ForeignKey(Room)

    class Meta:

        unique_together = [("slot", "room")]

        ordering = ["slot", "room__order"]

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

    def speakers(self):

        yield self.speaker

        for speaker in self.additional_speakers.all():

            if speaker.user:

                yield speaker

    class Meta:

        ordering = ["slot"]

class Session(models.Model):

    day = models.ForeignKey(Day, related_name="sessions")

    slots = models.ManyToManyField(Slot, related_name="sessions")

    def sorted_slots(self):

        slots = self.sorted_slots()

        if slots:

            return list(slots)[-1].end

        else:

            return None

        start = self.start()

        end = self.end()

        if start and end:

                self.day.date.strftime("%a"),

                start.strftime("%X"),

                end.strftime("%X")

            )

class SessionRole(models.Model):

    SESSION_ROLE_CHAIR = 1

    SESSION_ROLE_RUNNER = 2

    SESSION_ROLE_TYPES = [

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

    class Meta:

        unique_together = [("session", "user", "role")]

import itertools

from django.db.models import Count, Min

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

from django.conf.urls import url, patterns

urlpatterns = patterns(

    "symposion.schedule.views",

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

import json

from django.core.urlresolvers import reverse

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 import admin

from symposion.speakers.models import Speaker

admin.site.register(Speaker,

from django.apps import AppConfig

class SpeakersConfig(AppConfig):

    name = "symposion.speakers"

    label = "symposion_speakers"

from django import forms

from markitup.widgets import MarkItUpWidget

from symposion.speakers.models import Speaker

import datetime

from django.db import models

from django.core.urlresolvers import reverse

from django.contrib.auth.models import User

from markitup.fields import MarkupField

class Speaker(models.Model):

    SESSION_COUNT_CHOICES = [

        (1, "One"),

        (2, "Two")

    ]

        editable=False

    )

    class Meta:

        ordering = ['name']

        if self.user:

            return self.name

        else:

    def get_absolute_url(self):

        return reverse("speaker_edit")

    @property

    def email(self):

from django.conf.urls import patterns, url

urlpatterns = patterns(

    "symposion.speakers.views",

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

from django.core.exceptions import ObjectDoesNotExist

from django.http import Http404

from django.shortcuts import render, redirect, get_object_or_404

from django.contrib import messages

from django.contrib.auth.decorators import login_required

from django.contrib import admin

from django.utils.html import escape

from django.utils.safestring import mark_safe

from django.utils.translation import ugettext_lazy as _

from symposion.sponsorship.models import SponsorLevel, Sponsor, Benefit, BenefitLevel, \

from django import forms

from django.forms.models import inlineformset_factory, BaseInlineFormSet

from django.contrib.admin.widgets import AdminFileWidget

from symposion.sponsorship.models import Sponsor, SponsorBenefit

import datetime

from django.conf import settings

from django.core.exceptions import ValidationError

from django.core.urlresolvers import reverse

from django.db import models

from django.db.models.signals import post_init, post_save

from django.utils.translation import ugettext_lazy as _

from django.contrib.auth.models import User

from symposion.conference.models import Conference

from symposion.sponsorship.managers import SponsorManager

class SponsorLevel(models.Model):

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

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

    order = models.IntegerField(_("order"), default=0)

    cost = models.PositiveIntegerField(_("cost"))

    class Meta:

        ordering = ["conference", "order"]

        verbose_name = _("sponsor level")

        verbose_name_plural = _("sponsor levels")

        return self.name

    def sponsors(self):

        return self.sponsor_set.filter(active=True).order_by("added")

class Sponsor(models.Model):

    applicant = models.ForeignKey(User, related_name="sponsorships", verbose_name=_("applicant"),

                                  null=True)

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

    # Denormalization (this assumes only one logo)

    sponsor_logo = models.ForeignKey("SponsorBenefit", related_name="+", null=True, blank=True,

                                     editable=False)

    objects = SponsorManager()

        return self.name

    class Meta:

        verbose_name = _("sponsor")

        verbose_name_plural = _("sponsors")

    ("simple", "Simple"),

] + [

    ("listing_text_%s" % lang, "Listing Text (%s)" % label) for lang, label in settings.LANGUAGES

]

class Benefit(models.Model):

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

    description = models.TextField(_("description"), blank=True)

    type = models.CharField(_("type"), choices=BENEFIT_TYPE_CHOICES,

                            max_length=10, default="simple")

    content_type = models.CharField(_("content type"), choices=CONTENT_TYPE_CHOICES,

                                    max_length=20, default="simple")

        return self.name

class BenefitLevel(models.Model):

    benefit = models.ForeignKey(Benefit, related_name="benefit_levels", verbose_name=_("benefit"))

    level = models.ForeignKey(SponsorLevel, related_name="benefit_levels", verbose_name=_("level"))

    # default limits for this benefit at given level

    max_words = models.PositiveIntegerField(_("max words"), blank=True, null=True)

    other_limits = models.CharField(_("other limits"), max_length=200, blank=True)

    class Meta:

        ordering = ["level"]