django-appconf==1.0.1

django-model-utils==2.4.0

django-reversion==1.10.1

django-sitetree==1.5.1

django-taggit==0.18.0

django-timezone-field==1.3

django-user-accounts==1.3.1

easy-thumbnails==2.3

html5lib==0.9999999

markdown==2.6.5

pytz==2015.7

    def additional_speaker_validator(self, a_speaker):

        if a_speaker.speaker.email == self.speaker.email:

            raise ValidationError(_("%s is same as primary speaker.") % a_speaker.speaker.email)

        if a_speaker in [self.additional_speakers]:

            raise ValidationError(_("%s has already been in speakers.") % a_speaker.speaker.email)

    additional_speakers = models.ManyToManyField(Speaker, through="AdditionalSpeaker",

                                                 blank=True, verbose_name=_("Addtional speakers"))

    cancelled = models.BooleanField(default=False, verbose_name=_("Cancelled"))

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

        self.abstract_html = parse(self.abstract)

        self.private_abstract_html = parse(self.private_abstract)

        self.technical_requirements_html = parse(self.technical_requirements)

        return super(ProposalBase, self).save(*args, **kwargs)

    def can_edit(self):

        return True

    @property

    def section(self):

        return self.kind.section

    @property

    def speaker_email(self):

        return self.speaker.email

    @property

    def number(self):

        return str(self.pk).zfill(3)

    @property

    def status(self):

        try:

            return self.result.status

        except ObjectDoesNotExist:

            return _('Undecided')

    def speakers(self):

        yield self.speaker

        speakers = self.additional_speakers.exclude(

            additionalspeaker__status=AdditionalSpeaker.SPEAKING_STATUS_DECLINED)

        for speaker in speakers:

            yield speaker

    def notification_email_context(self):

        return {

            "title": self.title,

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

            "kind": self.kind.name,

        }

    def __str__(self):

        return self.title

reversion.register(ProposalBase)

@python_2_unicode_compatible

class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1

    SPEAKING_STATUS_ACCEPTED = 2

    SPEAKING_STATUS_DECLINED = 3

    SPEAKING_STATUS = [

        (SPEAKING_STATUS_PENDING, _("Pending")),

        (SPEAKING_STATUS_ACCEPTED, _("Accepted")),

        (SPEAKING_STATUS_DECLINED, _("Declined")),

    ]

    speaker = models.ForeignKey(Speaker, verbose_name=_("Speaker"))

    proposalbase = models.ForeignKey(ProposalBase, verbose_name=_("Proposalbase"))

    status = models.IntegerField(choices=SPEAKING_STATUS, default=SPEAKING_STATUS_PENDING, verbose_name=_("Status"))

    class Meta:

        unique_together = ("speaker", "proposalbase")

        verbose_name = _("Addtional speaker")

        verbose_name_plural = _("Additional speakers")

    def __str__(self):

        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

def uuid_filename(instance, filename):

    ext = filename.split(".")[-1]

    filename = "%s.%s" % (uuid.uuid4(), ext)

    return os.path.join("document", filename)

class SupportingDocument(models.Model):

    class Meta:

        verbose_name = _("comment")

        verbose_name_plural = _("comments")

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

        self.text_html = parse(self.text)

        return super(Comment, self).save(*args, **kwargs)

class NotificationTemplate(models.Model):

    label = models.CharField(max_length=100, verbose_name=_("Label"))

    from_address = models.EmailField(verbose_name=_("From address"))

    subject = models.CharField(max_length=100, verbose_name=_("Subject"))

    body = models.TextField(verbose_name=_("Body"))

    class Meta:

        verbose_name = _("notification template")

        verbose_name_plural = _("notification templates")

class ResultNotification(models.Model):

    proposal = models.ForeignKey(ProposalBase, related_name="notifications", verbose_name=_("Proposal"))

    template = models.ForeignKey(NotificationTemplate, null=True, blank=True,

                                 on_delete=models.SET_NULL, verbose_name=_("Template"))

    timestamp = models.DateTimeField(default=datetime.now, verbose_name=_("Timestamp"))

    to_address = models.EmailField(verbose_name=_("To address"))

    from_address = models.EmailField(verbose_name=_("From address"))

    subject = models.CharField(max_length=100, verbose_name=_("Subject"))

    body = models.TextField(verbose_name=_("Body"))

    def recipients(self):

        for speaker in self.proposal.speakers():

            yield speaker.email

    @property

    def email_args(self):

        return (self.subject, self.body, self.from_address, self.recipients())

def promote_proposal(proposal):

    if hasattr(proposal, "presentation") and proposal.presentation:

        # already promoted

        presentation = proposal.presentation

    else:

        presentation = Presentation(

            title=proposal.title,

            abstract=proposal.abstract,

            speaker=proposal.speaker,

            section=proposal.section,

            proposal_base=proposal,

        )

        presentation.save()

        for speaker in proposal.additional_speakers.all():

            presentation.additional_speakers.add(speaker)

            presentation.save()

    return presentation

def unpromote_proposal(proposal):

    if hasattr(proposal, "presentation") and proposal.presentation:

        proposal.presentation.delete()

def accepted_proposal(sender, instance=None, **kwargs):

    if instance is None:

        return

    if instance.status == "accepted":

        promote_proposal(instance.proposal)

    else:

        unpromote_proposal(instance.proposal)

post_save.connect(accepted_proposal, sender=ProposalResult)

    ctx = {

        "section_slug": section_slug,

        "status": status,

        "notification_template": notification_template,

        "proposals": proposals,

        "proposal_pks": ",".join([str(pk) for pk in proposal_pks]),

    }

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

@login_required

def result_notification_send(request, section_slug, status):

    if request.method != "POST":

        return HttpResponseNotAllowed(["POST"])

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

        return access_not_permitted(request)

    if not all([k in request.POST for k in ["proposal_pks", "from_address", "subject", "body"]]):

        return HttpResponseBadRequest()

    try:

        proposal_pks = [int(pk) for pk in request.POST["proposal_pks"].split(",")]

    except ValueError:

        return HttpResponseBadRequest()

    proposals = ProposalBase.objects.filter(

        kind__section__slug=section_slug,

        result__status=status,

    )

    proposals = proposals.filter(pk__in=proposal_pks)

    proposals = proposals.select_related("speaker__user", "result")

    proposals = proposals.select_subclasses()

    notification_template_pk = request.POST.get("notification_template", "")

    if notification_template_pk:

        notification_template = NotificationTemplate.objects.get(pk=notification_template_pk)

    else:

        notification_template = None

    emails = []

    for proposal in proposals:

        rn = ResultNotification()

        rn.proposal = proposal

        rn.template = notification_template

        rn.to_address = proposal.speaker_email

        rn.from_address = request.POST["from_address"]

        rn.body = Template(request.POST["body"]).render(

            Context({

                "proposal": proposal.notification_email_context()

            })

        )

        rn.save()

        emails.append(rn.email_args)

    send_mass_mail(emails)

    return redirect("result_notification", section_slug=section_slug, status=status)

    @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 save(self, *args, **kwargs):

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

        self.name = "%s %s (%s - %s) %s" % (self.day, self.kind, self.start, self.end, roomlist)

        self.content_override_html = parse(self.content_override)

        super(Slot, self).save(*args, **kwargs)

    def __str__(self):

        return self.name

    class Meta:

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

        verbose_name = _("slot")

        verbose_name_plural = _("slots")

@python_2_unicode_compatible

class SlotRoom(models.Model):

    """

    Links a slot with a room.

    """

    slot = models.ForeignKey(Slot, verbose_name=_("Slot"))

    room = models.ForeignKey(Room, verbose_name=_("Room"))

    def __str__(self):

        return "%s %s" % (self.room, self.slot)

    class Meta:

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

        ordering = ["slot", "room__order"]

        verbose_name = _("Slot room")

        verbose_name_plural = _("Slot rooms")

@python_2_unicode_compatible

class Presentation(models.Model):

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

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

    abstract = models.TextField(verbose_name=_("Abstract"))

    abstract_html = models.TextField(blank=True)

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

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

                                                 blank=True, verbose_name=_("Additional speakers"))

    cancelled = models.BooleanField(default=False, verbose_name=_("Cancelled"))

    proposal_base = models.OneToOneField(ProposalBase, related_name="presentation", verbose_name=_("Proposal base"))

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

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

        self.abstract_html = parse(self.abstract)

        return super(Presentation, self).save(*args, **kwargs)

    @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 __str__(self):

        return "#%s %s (%s)" % (self.number, self.title, self.speaker)

    class Meta:

        ordering = ["slot"]

        verbose_name = _("presentation")

        verbose_name_plural = _("presentations")

@python_2_unicode_compatible

class Session(models.Model):

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

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

    def sorted_slots(self):

        return self.slots.order_by("start")

    def start(self):

        slots = self.sorted_slots()

        if slots:

            return list(slots)[0].start

        else:

            return None

    def end(self):

        slots = self.sorted_slots()

        if slots:

            return list(slots)[-1].end

            raise Http404()

    else:

        schedule = None

    ctx = {

        "presentation": presentation,

        "schedule": schedule,

    }

    return render(request, "symposion/schedule/presentation_detail.html", ctx)

def schedule_json(request):

    slots = Slot.objects.filter(

        day__schedule__published=True,

        day__schedule__hidden=False

    ).order_by("start")

    protocol = request.META.get('HTTP_X_FORWARDED_PROTO', 'http')

    data = []

    for slot in slots:

        slot_data = {

            "room": ", ".join(room["name"] for room in slot.rooms.values()),

            "rooms": [room["name"] for room in slot.rooms.values()],

            "start": slot.start_datetime.isoformat(),

            "end": slot.end_datetime.isoformat(),

            "duration": slot.length_in_minutes,

            "kind": slot.kind.label,

            "section": slot.day.schedule.section.slug,

            "conf_key": slot.pk,

            # TODO: models should be changed.

            # these are model features from other conferences that have forked symposion

            # these have been used almost everywhere and are good candidates for

            # base proposals

            "license": "CC BY",

            "tags": "",

            "released": True,

            "contact": [],

        }

        if hasattr(slot.content, "proposal"):

            slot_data.update({

                "name": slot.content.title,

                "authors": [s.name for s in slot.content.speakers()],

                "contact": [

                    s.email for s in slot.content.speakers()

                ] if request.user.is_staff else ["redacted"],

                "abstract": slot.content.abstract.raw,

                "conf_url": "%s://%s%s" % (

                    protocol,

                    Site.objects.get_current().domain,

                    reverse("schedule_presentation_detail", args=[slot.content.pk])

                ),

                "cancelled": slot.content.cancelled,

            })

        else:

            slot_data.update({

                "name": slot.content_override.raw if slot.content_override else "Slot",

            })

        data.append(slot_data)

    return HttpResponse(

        json.dumps({"schedule": data}),

        content_type="application/json"

    )

def session_list(request):

    sessions = Session.objects.all().order_by('pk')

    return render(request, "symposion/schedule/session_list.html", {

        "sessions": sessions,

    })

@login_required

def session_staff_email(request):

    if not request.user.is_staff:

        return redirect("schedule_session_list")

    data = "\n".join(user.email for user in User.objects.filter(sessionrole__isnull=False).distinct())

    return HttpResponse(data, content_type="text/plain;charset=UTF-8")

def session_detail(request, session_id):

    session = get_object_or_404(Session, id=session_id)

    chair = None

    chair_denied = False

    chairs = SessionRole.objects.filter(session=session, role=SessionRole.SESSION_ROLE_CHAIR).exclude(status=False)

    if chairs:

        chair = chairs[0].user

    else: