fet2020/fet2020/members/models.py

from django.core.validators import RegexValidator, ValidationError
from django.db import models
from django.db.models import Q
from django.utils import timezone
from django.utils.text import slugify
from django.utils.translation import gettext_lazy as _

from datetime import timedelta
from easy_thumbnails.fields import ThumbnailerImageField
from rest_framework import serializers


class MemberQuerySet(models.QuerySet):
    def get_active(self):
        date_today = timezone.now().date()

        return self.filter(
            Q(member__role=Member.MemberRole.ACTIVE)
            & (Q(job_end__gt=date_today) | Q(job_end__isnull=True))
        )

    def get_inactive(self):
        date_today = timezone.now().date()

        return self.filter(
            Q(member__role=Member.MemberRole.PENSION)
            | (Q(job_end__lt=date_today + timedelta(days=1)) & Q(job_end__isnull=False))
        )


class ActiveMemberManager(models.Manager):
    '''
    return a list of active member, and members who are still working
    '''
    def get_members_of_job(self, job_names):
        tmp_list = []
        for job_name in job_names:
            tmp_list.append(self.get_queryset().get_active().filter(Q(job__name=job_name)))
        return tmp_list

    def get_all(self):
        return self.get_queryset().get_active()

    def get_queryset(self):
        return MemberQuerySet(self.model, using=self._db)


class InactiveMemberManager(models.Manager):
    '''
    return a list of inactive member
    '''
    def get_members_of_job(self, job_names):
        tmp_list = []
        for job_name in job_names:
            tmp_list.append(self.get_queryset().get_inactive().filter(Q(job__name=job_name)))
        return tmp_list

    def get_all(self):
        return self.get_queryset().get_inactive()

    def get_queryset(self):
        return MemberQuerySet(self.model, using=self._db)


class MemberManager(models.Manager):
    def get_members(self, role):
        return self.get_queryset().filter(Q(member__role=role))

    def get_all(self):
        return self.get_queryset()


class JobManager(models.Manager):
    def get_job_names(self, slug):
        job_list = []
        slug_list = []
        for i in self.get_queryset().filter(Q(job__job_group__slug=slug)):
            if i.job.name not in job_list:
                job_list.append(i.job.name)
                slug_list.append(i.job.slug)
        return job_list, slug_list


class Member(models.Model):
    firstname = models.CharField(max_length=128)
    surname = models.CharField(max_length=128)
    nickname = models.CharField(max_length=128)
    mailaccount = models.CharField(max_length=128)

    class MemberRole(models.TextChoices):
        ACTIVE = 'A', _('Active')
        PENSION = 'P', _('Pension')

    role = models.CharField(max_length=1, choices=MemberRole.choices, default=MemberRole.ACTIVE)

    description = models.TextField(null=True, blank=True)
    image = ThumbnailerImageField()

    birthday = models.DateField(null=True, blank=True)

    phone_error_msg = _((
        "Phone number must be entered in the format: +999999999'. Up to 15 digits allowed."
    ))
    phone_regex = RegexValidator(regex=r'^\+?1?\d{9,15}$', message=phone_error_msg)
    phone = models.CharField(validators=[phone_regex], max_length=17, blank=True)

    address = models.TextField(null=True, blank=True)

    date_modified = models.DateTimeField(auto_now=True)
    date_created = models.DateTimeField(auto_now_add=True)

    # Managers
    all_members = models.Manager()

    class Meta:
        verbose_name = "Mitglied"
        verbose_name_plural = "Mitglieder"

    def clean(self):
        if self.image.height < 150 or self.image.width < 150:
            raise ValidationError(
                _('Das Bild ist zu klein. (Höhe: {}, Breite: {})').format(
                    self.image.height,
                    self.image.width
                )
            )

    def __str__(self):
        return self.firstname + " " + self.surname


class MemberSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Member
        fields = [
            'firstname',
            'surname',
            'nickname',
            'mailaccount',
            'role',
            'description',
            'image',
        ]


class JobGroup(models.Model):
    name = models.CharField(max_length=128)
    shortterm = models.CharField(max_length=128)

    slug = models.SlugField(unique=True, null=True, blank=True)

    is_pinned = models.BooleanField(default=False)

    class Meta:
        verbose_name = "Tätigkeit-Gruppierung"
        verbose_name_plural = "Tätigkeit-Gruppierungen"

    def __str__(self):
        return self.name


class Job(models.Model):
    name = models.CharField(max_length=128)
    shortterm = models.CharField(max_length=128)

    slug = models.SlugField(unique=True, null=True, blank=True)

    description = models.TextField(null=True, blank=True)
    image = models.ImageField(null=True, blank=True)

    job_group = models.ForeignKey(
        JobGroup,
        on_delete=models.CASCADE,
        verbose_name="Job Gruppe",
    )

    class Meta:
        verbose_name = "Tätigkeit"
        verbose_name_plural = "Tätigkeiten"

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.shortterm)

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

    def __str__(self):
        return self.shortterm


class JobMember(models.Model):
    member = models.ForeignKey(
        Member,
        on_delete=models.CASCADE,
        verbose_name="Mitglied",
    )
    job = models.ForeignKey(
        Job,
        on_delete=models.CASCADE,
        verbose_name="Tätigkeit",
    )

    job_start = models.DateField('Job Start')
    job_end = models.DateField('Job Ende', null=True, blank=True)

    class JobRole(models.TextChoices):
        PRESIDENT = '1V', _('VorsitzendeR')
        VICE_PRESIDENT = '2V', _('stv VorsitzendeR')
        SECOND_VICE_PRESIDENT = '3V', _('2. stv VorsitzendeR')
        MEMBER = 'M', _('Mitglied')
        SUBSTITUTE_MEMBER = 'E', _('Ersatzmitglied')
        PERSON_RESPONSIBLE = 'V', _('VerantwortlicheR')

    job_role = models.CharField(max_length=2, choices=JobRole.choices, default=JobRole.MEMBER)

    members = MemberManager()
    active_member = ActiveMemberManager()
    inactive_member = InactiveMemberManager()

    jobs = JobManager()