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

    # when the conference runs

    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)

    def __unicode__(self):

        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]

    def delete(self):

        pk = self.pk

        super(Conference, self).delete()

        try:

            del CONFERENCE_CACHE[pk]

        except KeyError:

            pass

    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.

    """

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

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

    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)

    def __unicode__(self):

    class Meta(object):

        verbose_name = _("section")

        verbose_name_plural = _("sections")

        ordering = ["start_date"]

def current_conference():

    from django.conf import settings

    try:

        conf_id = settings.CONFERENCE_ID

    except AttributeError:

        from django.core.exceptions import ImproperlyConfigured

        raise ImproperlyConfigured("You must set the CONFERENCE_ID setting.")

    try:

        current_conf = CONFERENCE_CACHE[conf_id]

    except KeyError:

        current_conf = Conference.objects.get(pk=conf_id)

        CONFERENCE_CACHE[conf_id] = current_conf

    return current_conf

import datetime

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

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)

    def __unicode__(self):

    class Meta:

        ordering = ["section"]

class Day(models.Model):

    schedule = models.ForeignKey(Schedule)

    date = models.DateField()

    def __unicode__(self):

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

    def __unicode__(self):

        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)

    def __unicode__(self):

        return self.label

class Slot(models.Model):

    day = models.ForeignKey(Day)

    kind = models.ForeignKey(SlotKind)

    start = models.TimeField()

    end = models.TimeField()

    content_override = MarkupField(blank=True)

    def assign(self, content):

        """

        Assign the given content to this slot and if a previous slot content

        was given we need to unlink it to avoid integrity errors.

        """

        self.unassign()

        content.slot = self

        content.save()

    def unassign(self):

        """

        Unassign the associated content with this slot.

        """

        content = self.content

        if content and content.slot_id:

            content.slot = None

            content.save()

    @property

    def content(self):

        """

        Return the content this slot represents.

        @@@ hard-coded for presentation for now

        """

        try:

            return self.content_ptr

        except ObjectDoesNotExist:

            return None

    @property

    def start_datetime(self):

        return datetime.datetime(

            self.day.date.year,

            self.day.date.month,

            self.day.date.day,

            self.start.hour,

            self.start.minute)

    @property

    def end_datetime(self):

        return datetime.datetime(

            self.day.date.year,

            self.day.date.month,

            self.day.date.day,

            self.end.hour,

            self.end.minute)

    @property

    def length_in_minutes(self):

        return int(

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

    @property

    def rooms(self):

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

    def __unicode__(self):

    class Meta:

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

class SlotRoom(models.Model):

    """

    Links a slot with a room.

    """

    slot = models.ForeignKey(Slot)

    room = models.ForeignKey(Room)

    def __unicode__(self):

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

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

    additional_speakers = models.ManyToManyField(Speaker, related_name="copresentations",

                                                 blank=True)

    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

    @property

    def proposal(self):

        if self.proposal_base_id is None:

            return None

        return ProposalBase.objects.get_subclass(pk=self.proposal_base_id)

    def speakers(self):

        yield self.speaker

        for speaker in self.additional_speakers.all():

            if speaker.user:

                yield speaker

    def __unicode__(self):

    class Meta:

        ordering = ["slot"]

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

    ]

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

    name = models.CharField(max_length=100, help_text=("As you would like it to appear in the "

                                                       "conference program."))

    biography = MarkupField(blank=True, help_text=("A little bit about you.  Edit using "

                                                   "<a href='http://warpedvisions.org/projects/"

                                                   "markdown-cheat-sheet/target='_blank'>"

                                                   "Markdown</a>."))

    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,

        editable=False

    )

    class Meta:

        ordering = ['name']

    def __unicode__(self):

        if self.user:

            return self.name

        else:

    def get_absolute_url(self):

        return reverse("speaker_edit")

    @property

    def email(self):

        if self.user is not None:

            return self.user.email

        else:

            return self.invite_email

    @property

    def all_presentations(self):

        presentations = []

        if self.presentations:

            for p in self.presentations.all():

                presentations.append(p)

            for p in self.copresentations.all():

                presentations.append(p)

        return presentations