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)

    created_by = models.ForeignKey(User, related_name="boxes")

    last_updated_by = models.ForeignKey(User, related_name="updated_boxes")

        return self.label

    class Meta:

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 .managers import PublishedPageManager

class Page(models.Model):

    STATUS_CHOICES = (

    published = PublishedPageManager()

        return self.title

    @models.permalink

from django.apps import AppConfig

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.

    # timezone the conference is in

    timezone = TimeZoneField(_("timezone"), blank=True)

        return self.title

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

        verbose_name_plural = _("conferences")

class Section(models.Model):

    """

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

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

from html5lib import html5parser, sanitizer

import markdown

import csv

from django.http import HttpResponse

from django.apps import AppConfig

from django import forms

from django.db.models import Q

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 symposion.speakers.models import Speaker

class ProposalSection(models.Model):

    """

    configuration of proposal submissions for a specific Section.

            return False

        return True

        return self.section.name

class ProposalKind(models.Model):

    """

    e.g. talk vs panel vs tutorial vs poster

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

    slug = models.SlugField()

        return self.name

class ProposalBase(models.Model):

    objects = InheritanceManager()

            "kind": self.kind.name,

        }

reversion.register(ProposalBase)

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    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:

import hashlib

import random

import sys

from django.apps import AppConfig

from django import forms

from markitup.widgets import MarkItUpWidget

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

from datetime import datetime

from decimal import Decimal

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

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

    """

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

from django.contrib import admin

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

from django.apps import AppConfig

import csv

import time

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

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.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

    schedule = models.ForeignKey(Schedule)

    label = models.CharField(max_length=50)

        return self.label

class Slot(models.Model):

    day = models.ForeignKey(Day)

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

            if speaker.user:

                yield speaker

    class Meta:

        ordering = ["slot"]

class Session(models.Model):

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

        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

    class Meta:

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

import itertools

from django.db.models import Count, Min

from django.conf.urls import url, patterns

import json

from django.core.urlresolvers import reverse

from django.contrib import admin

from symposion.speakers.models import Speaker

from django.apps import AppConfig

from django import forms

from markitup.widgets import MarkItUpWidget

import datetime

from django.db import models

from django.core.urlresolvers import reverse

from markitup.fields import MarkupField

class Speaker(models.Model):

    SESSION_COUNT_CHOICES = [

    class Meta:

        ordering = ['name']

        if self.user:

            return self.name

        else:

    def get_absolute_url(self):

        return reverse("speaker_edit")

from django.conf.urls import patterns, url

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 admin

from django.utils.html import escape

from django.utils.safestring import mark_safe

from django import forms

from django.forms.models import inlineformset_factory, BaseInlineFormSet

import datetime

from django.conf import settings

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.sponsorship.managers import SponsorManager

class SponsorLevel(models.Model):

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

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

    objects = SponsorManager()

        return self.name

    class Meta:

]

class Benefit(models.Model):

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

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

    class Meta:

        ordering = ["level"]

class SponsorBenefit(models.Model):

    sponsor = models.ForeignKey(Sponsor, related_name="sponsor_benefits", verbose_name=_("sponsor"))

    class Meta:

        ordering = ["-active"]

    def clean(self):

        num_words = len(self.text.split())

from cStringIO import StringIO

import itertools

import logging

from django import forms

from django.utils.html import escape

import datetime

from django.db import models

import reversion

from django.contrib.auth.models import Permission, User

TEAM_ACCESS_CHOICES = [

]

class Team(models.Model):

    slug = models.SlugField(unique=True)

    def get_absolute_url(self):

        return ("team_detail", [self.slug])

        return self.name

    def get_state_for_user(self, user):

from django.http import Http404, HttpResponseNotAllowed

from django.shortcuts import render, redirect, get_object_or_404

import hashlib

import random