djadhere/services/models.py

from django.db import models
from django.db.models import Q
from django.core.validators import MaxValueValidator
from django.utils import timezone
from django.contrib.auth.models import Group
from django.contrib.contenttypes.fields import GenericRelation
from django.core.exceptions import ValidationError

from djadhere.utils import get_active_filter, is_overlapping
from adhesions.models import Adherent
from banking.models import Payment


class IPResource(models.Model):
    ip = models.GenericIPAddressField(verbose_name='IP')
    mask = models.PositiveIntegerField(validators=[MaxValueValidator(128)],
                                       default=0, verbose_name='Masque')

    @property
    def in_use(self):
        if self.allocations.filter(get_active_filter()).exists():
            return True
        else:
            return False

    class Meta:
        verbose_name = 'Ressource IP'
        verbose_name_plural = 'Ressources IP'

    def __str__(self):
        r = str(self.ip)
        if self.mask:
            r += '/%d' % self.mask
        return r


class ServiceType(models.Model):
    name = models.CharField(max_length=64, verbose_name='Nom', unique=True)
    group = models.ForeignKey(Group, null=True, blank=True,
                              verbose_name='Groupe de gestion',
                              related_name='service_types')

    class Meta:
        verbose_name = 'Type de service'
        verbose_name_plural = 'Types de service'

    def __str__(self):
        return self.name


class Service(models.Model):
    adherent = models.ForeignKey(Adherent, verbose_name='Adhérent', null=True, blank=True)
    service_type = models.ForeignKey(ServiceType, related_name='services',
                                     verbose_name='Type de service')
    label = models.CharField(blank=True, default='', max_length=128)
    notes = models.TextField(blank=True, default='')
    active = models.BooleanField(default=True, verbose_name='actif')
    created = models.DateTimeField(auto_now_add=True)
    contributions = GenericRelation(Payment,
                                   content_type_field='reason_type',
                                   object_id_field='reason_id',
                                   related_query_name='service')

    @property
    def contribution(self):
        try:
            return self.contributions.get(get_active_filter())
        except Payment.DoesNotExist:
            return None
        # MultipleObjectsReturned non catché volontairement, cf remarque adhesions.Adherent.contribution

    @property
    def active_allocations(self):
        return self.allocations.filter(get_active_filter())

    @property
    def inactive_allocations(self):
        return self.allocations.exclude(get_active_filter())

    def clean(self):
        super().clean()
        # Vérification de l’unicité par type de service du label
        if self.label != '' and Service.objects.exclude(pk=self.pk).filter(service_type=self.service_type, label=self.label):
            raise ValidationError("Un service du même type existe déjà avec ce label.")

    def __str__(self):
        s = str(self.service_type)
        if self.label:
            s += ' ' + self.label
        s += ' (' + str(self.adherent) + ')'
        return s


class ResourceAllocation(models.Model):
    resource = models.ForeignKey(IPResource, verbose_name='Ressource', related_name='allocations', related_query_name='allocation')
    service = models.ForeignKey(Service, related_name='allocations', related_query_name='allocation')
    start = models.DateTimeField(verbose_name='Début de la période d’allocation')
    end = models.DateTimeField(null=True, blank=True, verbose_name='Fin de la période d’allocation')

    def clean(self):
        super().clean()
        # Vérification de la cohérence des champs start et end
        if self.end and self.start > self.end:
            raise ValidationError("La date de début de l’allocation doit être antérieur "
                                  "à la date de fin de l’allocation.")
        # Vérification de l’abscence de chevauchement de la période d’allocation
        allocations = ResourceAllocation.objects.filter(resource__pk=self.resource.pk)
        if is_overlapping(self, allocations):
            raise ValidationError("La période d’allocation de cette ressource chevauche "
                                    "avec une période d’allocation précédente.")

    class Meta:
        verbose_name = 'Allocation de ressource'
        verbose_name_plural = 'Allocations de ressources'

    def __str__(self):
        return str(self.resource) + ' pour ' + str(self.service)