PonyConf/cfp/models.py

from django.contrib.auth.models import User
from django.contrib.sites.models import Site
from django.conf import settings
from django.urls import reverse
from django.core.validators import MaxValueValidator, MinValueValidator
from django.core.exceptions import ValidationError
from django.db import models
from django.db.models import Q, Count, Avg, Case, When
from django.db.models.functions import Coalesce
from django.utils import timezone
from django.utils.translation import gettext, gettext_lazy as _
from django.utils.safestring import mark_safe
from django.utils.html import escape, format_html

from autoslug import AutoSlugField
from colorful.fields import RGBColorField
from functools import partial
import phonenumbers

import uuid
from datetime import timedelta
from os.path import join, basename

from ponyconf.utils import PonyConfModel
from mailing.models import MessageThread



class Conference(models.Model):
    site = models.OneToOneField(Site, on_delete=models.CASCADE)

    name = models.CharField(blank=True, max_length=100, verbose_name=_('Conference name'))
    home = models.TextField(blank=True, default="", verbose_name=_('Homepage (markdown)'))
    venue = models.TextField(blank=True, default="", verbose_name=_('Venue information'))
    city = models.CharField(max_length=64, blank=True, default="", verbose_name=_('City'))
    contact_email = models.CharField(max_length=100, blank=True, verbose_name=_('Contact email'))
    reply_email = models.CharField(max_length=100, blank=True, verbose_name=_('Reply email'))
    staff = models.ManyToManyField(User, blank=True, verbose_name=_('Staff members'))
    secure_domain = models.BooleanField(default=True, verbose_name=_('Secure domain (HTTPS)'))
    acceptances_disclosure_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('Acceptances disclosure date'))
    schedule_publishing_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('Schedule publishing date'))
    schedule_redirection_url = models.URLField(blank=True, default='', verbose_name=_('Schedule redirection URL'),
                                               help_text=_('If specified, schedule tab will redirect to this URL.'))
    volunteers_opening_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('Volunteers enrollment opening date'))
    volunteers_closing_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('Volunteers enrollment closing date'))
    video_publishing_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('Video publishing date'))
    end_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('End of the conference date'))

    custom_css = models.TextField(blank=True)
    external_css_link = models.URLField(blank=True)

    def volunteers_enrollment_is_open(self):
        now = timezone.now()
        opening = self.volunteers_opening_date
        closing = self.volunteers_closing_date
        return opening and opening < now and (not closing or closing > now)

    @property
    def completed(self):
        return self.end_date and self.end_date <= timezone.now()

    @property
    def opened_categories(self):
        now = timezone.now()
        return TalkCategory.objects.filter(site=self.site)\
                            .filter(Q(opening_date__isnull=True) | Q(opening_date__lte=now))\
                            .filter(Q(closing_date__isnull=True) | Q(closing_date__gte=now))

    @property
    def disclosed_acceptances(self):
        # acceptances are automatically disclosed if the schedule is published
        return (self.acceptances_disclosure_date and self.acceptances_disclosure_date <= timezone.now()) or self.schedule_available

    @property
    def schedule_available(self):
        return self.schedule_publishing_date and self.schedule_publishing_date <= timezone.now()

    @property
    def videos_available(self):
        return self.video_publishing_date and self.video_publishing_date <= timezone.now()

    def from_email(self):
        return self.name+' <'+self.contact_email+'>'

    def clean_fields(self, exclude=None):
        super().clean_fields(exclude)
        if self.reply_email is not None:
            try:
                self.reply_email.format(token='a' * 80)
            except Exception:
                raise ValidationError({
                    'reply_email': _('The reply email should be a formatable string accepting a token argument (e.g. ponyconf+{token}@exemple.com).'),
                })

    def __str__(self):
        return self.name


class ParticipantManager(models.Manager):
    def get_queryset(self):
        qs = super().get_queryset()
        qs = qs.annotate(
            accepted_talk_count=Count(Case(When(Q(talk__accepted=True) & (Q(talk__confirmed=True) | Q(talk__confirmed__isnull=True)), then='talk__pk'), output_field=models.IntegerField()), distinct=True),
            pending_talk_count=Count(Case(When(talk__accepted=None, then='talk__pk'), output_field=models.IntegerField()), distinct=True),
            refused_talk_count=Count(Case(When(talk__accepted=False, then='talk__pk'), output_field=models.IntegerField()), distinct=True),
            canceled_talk_count=Count(Case(When(talk__confirmed=False, then='talk__pk'), output_field=models.IntegerField()), distinct=True),
        )
        return qs


class Participant(PonyConfModel):
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=128, verbose_name=_('Name'))
    email = models.EmailField()
    biography = models.TextField(verbose_name=_('Biography'))
    token = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    twitter = models.CharField(max_length=100, blank=True, default='', verbose_name=_('Twitter'))
    linkedin = models.CharField(max_length=100, blank=True, default='', verbose_name=_('LinkedIn'))
    github = models.CharField(max_length=100, blank=True, default='', verbose_name=_('Github'))
    website = models.CharField(max_length=100, blank=True, default='', verbose_name=_('Website'))
    facebook = models.CharField(max_length=100, blank=True, default='', verbose_name=_('Facebook'))
    mastodon = models.CharField(max_length=100, blank=True, default='', verbose_name=_('Mastodon'))
    phone_number = models.CharField(max_length=64, blank=True, default='', verbose_name=_('Phone number'))
    language = models.CharField(max_length=10, blank=True)
    notes = models.TextField(default='', blank=True, verbose_name=_("Notes"),
                             help_text=_('This field is only visible by organizers.'))
    vip = models.BooleanField(default=False, verbose_name=_('Invited speaker'))
    conversation = models.OneToOneField(MessageThread, on_delete=models.PROTECT)

    objects = ParticipantManager()

    def get_absolute_url(self):
        return reverse('participant-details', kwargs={'participant_id': self.pk})

    def get_secret_url(self, full=False):
        url = reverse('proposal-dashboard', kwargs={'speaker_token': self.token})
        if full:
            url = ('https' if self.site.conference.secure_domain else 'http') + '://' + self.site.domain + url
        return url

    def get_csv_row(self):
        return map(partial(getattr, self), ['pk', 'name', 'email', 'biography', 'twitter', 'linkedin', 'github', 'website', 'facebook', 'mastodon', 'phone_number', 'notes'])

    class Meta:
        # A User can participe only once to a Conference (= Site)
        unique_together = ('site', 'name')
        unique_together = ('site', 'email')

    def __str__(self):
        return str(self.name)

    @property
    def co_speaker_set(self):
        return Participant.objects.filter(site=self.site, talk__in=self.talk_set.values_list('pk')).exclude(pk=self.pk).order_by('name').distinct()

    @property
    def accepted_talk_set(self):
        return self.talk_set.filter(accepted=True).exclude(confirmed=False)
    @property
    def canceled_talk_set(self):
        return self.talk_set.filter(confirmed=False)
    @property
    def pending_talk_set(self):
        return self.talk_set.filter(accepted=None)
    @property
    def refused_talk_set(self):
        return self.talk_set.filter(accepted=False)


class Track(PonyConfModel):
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=128, verbose_name=_('Name'))
    slug = AutoSlugField(populate_from='name')
    description = models.TextField(blank=True, verbose_name=_('Description'))

    class Meta:
        unique_together = ('site', 'name')
        ordering = ['name']

    def estimated_duration(self):
        return sum([talk.estimated_duration for talk in self.talk_set.all()])

    def __str__(self):
        return self.name

    def get_absolute_url(self):
        return reverse('talk-list') + '?track=%s' % self.slug


class Room(models.Model):
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=256, blank=True, default='', verbose_name=_('Name'))
    slug = AutoSlugField(populate_from='name')
    label = models.CharField(max_length=256, blank=True, default='', verbose_name=_('Label'))
    capacity = models.IntegerField(default=0, verbose_name=_('Capacity'))

    class Meta:
        unique_together = ['site', 'name']
        ordering = ['name']

    def __str__(self):
        return self.name

    def get_absolute_url(self):
        return reverse('room-details', kwargs={'slug': self.slug})

    @property
    def talks(self):
        return self.talk_set.exclude(accepted=False)

    @property
    def talks_by_date(self):
        return self.talks.filter(start_date__isnull=False).exclude(duration=0, category__duration=0).order_by('start_date').all()

    @property
    def unscheduled_talks(self):
        return self.talks.filter(Q(start_date__isnull=True) | Q(duration=0, category__duration=0)).all()


class Tag(models.Model):
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=256, verbose_name=_('Name'))
    slug = AutoSlugField(populate_from='name')
    color = RGBColorField(default='#ffffff', verbose_name=_("Color"))
    inverted = models.BooleanField(default=False)
    public = models.BooleanField(default=False, verbose_name=_('Show the tag on the public program'))
    staff = models.BooleanField(default=False, verbose_name=_('Show the tag on the staff program'))

    def get_absolute_url(self):
        return reverse('tag-list')

    def get_filter_url(self):
        return reverse('talk-list') + '?tag=' + self.slug

    @property
    def link(self):
        return format_html('<a href="{url}">{content}</a>', **{
            'url': self.get_filter_url(),
            'content': self.label,
        })

    @property
    def label(self):
        return format_html('<span class="label" style="{style}">{name}</span>', **{
            'style': self.style,
            'name': self.name,
        })

    @property
    def style(self):
        return mark_safe('background-color: {bg}; color: {fg}; vertical-align: middle;'.format(**{
            'fg': '#fff' if self.inverted else '#000',
            'bg': self.color,
        }))

    def __str__(self):
        return self.name


class TalkCategory(models.Model): # type of talk (conf 30min, 1h, stand, …)
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=64)
    duration = models.PositiveIntegerField(default=0, verbose_name=_('Default duration (min)'))
    color = RGBColorField(default='#ffffff', verbose_name=_("Color on program"))
    label = models.CharField(max_length=64, verbose_name=_("Label on program"), blank=True, default="")
    opening_date = models.DateTimeField(null=True, blank=True, default=None)
    closing_date = models.DateTimeField(null=True, blank=True, default=None)

    def is_open(self):
        now = timezone.now()
        if self.opening_date and now < self.opening_date:
            return False
        if self.closing_date and now > self.closing_date:
            return False
        return True

    class Meta:
        unique_together = ('site', 'name')
        ordering = ('pk',)
        verbose_name = "category"
        verbose_name_plural = "categories"

    def __str__(self):
        return gettext(self.name)

    def get_absolute_url(self):
        return reverse('category-list')

    def get_filter_url(self):
        return reverse('talk-list') + '?category=%d' % self.pk


#class Attendee(PonyConfModel):
#
#    user = models.ForeignKey(User, null=True)
#    name = models.CharField(max_length=64, blank=True, default="")
#    email = models.EmailField(blank=True, default="")
#
#    def get_name(self):
#        if self.user:
#            return str(self.user.profile)
#        else:
#            return self.name
#    get_name.short_description = _('Name')
#
#    def get_email(self):
#        if self.user:
#            return self.user.email
#        else:
#            return self.email
#    get_email.short_description = _('Email')
#
#    def __str__(self):
#        return self.get_name()


class TalkManager(models.Manager):
    def get_queryset(self):
        qs = super().get_queryset()
        qs = qs.annotate(score=Coalesce(Avg('vote__vote'), 0.0))
        return qs


def talks_materials_destination(talk, filename):
    return join(talk.site.name, talk.slug, filename)


class Talk(PonyConfModel):
    LICENCES = (
        ('CC-Zero CC-BY', 'CC-Zero CC-BY'),
        ('CC-BY-SA', 'CC-BY-SA'),
        ('CC-BY-ND', 'CC-BY-ND'),
        ('CC-BY-NC', 'CC-BY-NC'),
        ('CC-BY-NC-SA','CC-BY-NC-SA'),
        ('CC-BY-NC-ND', 'CC-BY-NC-ND'),
    )

    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    speakers = models.ManyToManyField(Participant, verbose_name=_('Speakers'))
    title = models.CharField(max_length=128, verbose_name=_('Talk Title'))
    slug = AutoSlugField(populate_from='title', unique=True)
    description = models.TextField(verbose_name=_('Description of your talk'),
                                   help_text=_('This description will be visible on the program.'))
    track = models.ForeignKey(Track, blank=True, null=True, verbose_name=_('Track'), on_delete=models.SET_NULL)
    tags = models.ManyToManyField(Tag, blank=True)
    notes = models.TextField(blank=True, verbose_name=_('Message to organizers'),
                                   help_text=_('If you have any constraint or if you have anything that may '
                                               'help you to select your talk, like a video or slides of your'
                                               ' talk, please write it down here. This field will only be '
                                               'visible by organizers.'))
    category = models.ForeignKey(TalkCategory, verbose_name=_('Talk Category'), on_delete=models.PROTECT)
    videotaped = models.BooleanField(_("I'm ok to be recorded on video"), default=True)
    video_licence = models.CharField(choices=LICENCES, default='CC-BY-SA',
                                     max_length=32, verbose_name=_("Video licence"))
    sound = models.BooleanField(_("I need sound"), default=False)
    accepted = models.BooleanField(null=True, default=None)
    confirmed = models.BooleanField(null=True, default=None)
    start_date = models.DateTimeField(null=True, blank=True, default=None, verbose_name=_('Beginning date and time'))
    duration = models.PositiveIntegerField(default=0, verbose_name=_('Duration (min)'))
    room = models.ForeignKey(Room, blank=True, null=True, default=None, on_delete=models.SET_NULL)
    plenary = models.BooleanField(default=False)
    materials = models.FileField(null=True, blank=True, upload_to=talks_materials_destination, verbose_name=_('Materials'),
                                     help_text=_('You can use this field to share some materials related to your intervention.'))
    video = models.URLField(max_length=1000, blank=True, default='', verbose_name='Video URL')
    token = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    conversation = models.OneToOneField(MessageThread, on_delete=models.PROTECT)

    objects = TalkManager()

    class Meta:
        ordering = ('title',)

    def __str__(self):
        return self.title

    def get_speakers_str(self):
        speakers = list(map(str, self.speakers.all()))
        if len(speakers) == 0:
            return 'superman'
        elif len(speakers) == 1:
            return speakers[0]
        else:
            return ', '.join(speakers[:-1]) + ' & ' + str(speakers[-1])

    def get_status_str(self):
        if self.accepted is True:
            if self.confirmed is True:
                return _('Confirmed')
            elif self.confirmed is False:
                return _('Cancelled')
            else:
                return _('Waiting confirmation')
        elif self.accepted is False:
            return _('Refused')
        else:
            return _('Pending decision, score: %(score).1f') % {'score': self.score}

    def get_status_color(self):
        if self.accepted is True:
            if self.confirmed is True:
                return 'success'
            elif self.confirmed is False:
                return 'danger'
            else:
                return 'info'
        elif self.accepted is False:
            return 'default'
        else:
            return 'warning'

    def get_tags_html(self):
        return mark_safe(' '.join(map(lambda tag: tag.link, self.tags.all())))

    def get_csv_row(self):
        return [
            self.pk,
            self.title,
            self.description,
            self.category,
            self.track,
            [speaker.pk for speaker in self.speakers.all()],
            [speaker.name for speaker in self.speakers.all()],
            [tag.name for tag in self.tags.all()],
            1 if self.videotaped else 0,
            self.video_licence,
            1 if self.sound else 0,
            self.estimated_duration,
            self.room,
            1 if self.plenary else 0,
            self.materials,
            self.video,
        ]

    @property
    def estimated_duration(self):
        return self.duration or self.category.duration

    def get_absolute_url(self):
        return reverse('talk-details', kwargs={'talk_id': self.pk})

    @property
    def end_date(self):
        if self.estimated_duration:
            return self.start_date + timedelta(minutes=self.estimated_duration)
        else:
            return None

    @property
    def materials_name(self):
        return basename(self.materials.name)

    class Meta:
        ordering = ('category__id', 'title',)


class Vote(PonyConfModel):
    talk = models.ForeignKey(Talk, on_delete=models.CASCADE)
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    vote = models.IntegerField(validators=[MinValueValidator(-2), MaxValueValidator(2)], default=0)

    class Meta:
        unique_together = ('talk', 'user')

    def __str__(self):
        return "%+i by %s for %s" % (self.vote, self.user, self.talk)

    def get_absolute_url(self):
        return self.talk.get_absolute_url()


class Activity(models.Model):
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=256, verbose_name=_('Name'))
    slug = AutoSlugField(populate_from='name')
    description = models.TextField(blank=True, verbose_name=_('Description'))

    class Meta:
        unique_together = ('site', 'name')
        verbose_name = _('Activity')
        verbose_name_plural = _('Activities')

    def get_absolute_url(self):
        return reverse('activity-list')

    def get_filter_url(self):
        return reverse('volunteer-list') + '?activity=' + self.slug

    def __str__(self):
        return self.name


def validate_phone_number(phone_number: str):
    try:
        number = phonenumbers.parse(phone_number, region=settings.DEFAULT_PHONE_REGION)
    except phonenumbers.phonenumberutil.NumberParseException as err:
        raise ValidationError(str(err))
    else:
        if not phonenumbers.is_valid_number(number):
            raise ValidationError(_("Invalid phone number, try using the country code (like +33 for France)"))


class Volunteer(PonyConfModel):
    site = models.ForeignKey(Site, on_delete=models.CASCADE)
    name = models.CharField(max_length=128, verbose_name=_('Your Name'))
    email = models.EmailField(verbose_name=_('Email'))
    token = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
    phone_number = models.CharField(max_length=64, blank=True, default='', verbose_name=_('Phone number'), validators=[validate_phone_number])
    sms_prefered = models.BooleanField(default=False, verbose_name=_('SMS prefered'))
    language = models.CharField(max_length=10, blank=True)
    notes = models.TextField(default='', blank=True, verbose_name=_('Notes'),
                             help_text=_('If you have some constraints, you can indicate them here.'))
    activities = models.ManyToManyField(Activity, blank=True, related_name='volunteers', verbose_name=_('Activities'))
    conversation = models.OneToOneField(MessageThread, on_delete=models.PROTECT)

    def get_absolute_url(self):
        return reverse('volunteer-details', kwargs={'volunteer_id': self.pk})

    def get_secret_url(self, full=False):
        url = reverse('volunteer-dashboard', kwargs={'volunteer_token': self.token})
        if full:
            url = ('https' if self.site.conference.secure_domain else 'http') + '://' + self.site.domain + url
        return url

    def get_csv_row(self):
        return [
            self.pk,
            self.name,
            self.email,
            self.phone_number,
            1 if self.sms_prefered else 0,
            self.notes,
        ]

    class Meta:
        # A volunteer can participe only once to a Conference (= Site)
        unique_together = ('site', 'email')

    def __str__(self):
        return str(self.name)