coin/hardware_provisioning/models.py

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

import datetime
import pytz
from datetime import datetime
from django.db import models
from django.db.models import Q
from django.conf import settings
from django.utils import timezone
from django.db.models import Count, Q
from coin.offers.models import OfferSubscription

from .fields import MACAddressField


class ItemType(models.Model):
    name = models.CharField(max_length=100, verbose_name='nom')

    def __unicode__(self):
        return self.name

    class Meta:
        verbose_name = 'type d’objet'
        verbose_name_plural = 'types d’objet'


class ItemQuerySet(models.QuerySet):
    def _get_borrowed_pks(self, at_date=None):
        return Loan.objects.running(at_date).values_list('item', flat=True)

    def available(self):
        return self.exclude(
            pk__in=self._get_borrowed_pks()).exclude(deployed=True)

    def borrowed(self):
        return self.filter(pk__in=self._get_borrowed_pks())

    def deployed(self):
        return self.filter(deployed=True)

    def unavailable(self):
        """ deployed or borrowed
        """
        return self.filter(
            Q(pk__in=self._get_borrowed_pks()) |
            Q(deployed=True))

    def summary_item(self):
        """ Agregates as a count of items per designation
        """
        return self.values('designation').annotate(count_item=Count('designation'))

    def running(self, at_date=None):
        """ Only item at a given date or deployed
        """
        if at_date is None:
            at_date = timezone.now()

        return self.filter(Q(pk__in=self._get_borrowed_pks(at_date)) |
                           Q(deployed=True))

    
class Item(models.Model):
    type = models.ForeignKey(ItemType, verbose_name='type de matériel',
                             related_name='items')
    designation = models.CharField(max_length=100, verbose_name='désignation')
    storage = models.ForeignKey(
        'Storage', related_name='items',
        verbose_name='Lieu de stockage',
        null=True, blank=True,
        help_text='Laisser vide si inconnu')
    mac_address = MACAddressField(
        verbose_name='adresse MAC',
        blank=True, null=True, unique=True,
        help_text="préférable au n° de série si possible")
    serial = models.CharField(
        verbose_name='N° de série',
        max_length=250, blank=True, null=True, unique=True,
        help_text='ou toute autre référence unique')
    buy_date = models.DateField(verbose_name='date d’achat' , blank=True , null=True)
    owner = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        verbose_name='Propriétaire',
        related_name='items',
        null=True, blank=True,
        help_text="dans le cas de matériel n'appartenant pas à l'association")
    deployed = models.BooleanField(verbose_name='déployé', default=False,
                                   help_text='Cocher si le matériel est en production')
    comment = models.TextField(verbose_name='commentaire', blank=True,
                               null=True)

    objects = ItemQuerySet().as_manager()

    def __unicode__(self):
        return self.designation

    def save(self, *args, **kwargs):
        # workaround for unique=True, null=True
        # see https://code.djangoproject.com/ticket/4136#comment:33
        self.mac_address = self.mac_address or None
        self.serial = self.serial or None

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

    def get_current_loan(self):
        """
        Returns the current Loan for this Item, if exists, or None.
        """
        try:
            return self.loans.get(loan_date_end__isnull=True)
        except Loan.DoesNotExist:
            return None

    def is_available(self):
        """
        Returns the status of the Item. If a running loan exists,
        or if the item is deployed, returns False (else True).
        """
        return (not self.deployed) and (not self.loans.running().exists())
    is_available.boolean = True
    is_available.short_description = 'disponible'

    def get_mac_and_serial(self):
        mac = self.mac_address
        serial = self.serial
        if mac and serial:
            return "{} / {}".format(mac, serial)
        else:
            return mac or serial or ''

    class Meta:
        verbose_name = 'objet'
        ordering = ['designation', 'mac_address', 'serial']

    def give_back(self, storage=None):
        self.storage = storage
        self.save()
        self.loans.running().update(
            loan_date_end=timezone.now())


class LoanQuerySet(models.QuerySet):

    @staticmethod
    def _running_filter(at_date=None):
        if at_date is None:
            at_date = timezone.now()
        else:
            at_date = timezone.make_aware(datetime.strptime(at_date, "%Y-%m-%d"))
        return (
            models.Q(loan_date_end__gt=timezone.now()) |
            models.Q(loan_date_end__isnull=True) &
            models.Q(loan_date__lt=at_date))

    def running(self, at_date=None):
        return self.filter(self._running_filter(at_date))

    def finished(self):
        return self.exclude(self._running_filter())


class Loan(models.Model):
    item = models.ForeignKey(Item, verbose_name='objet', related_name='loans')
    user = models.ForeignKey(
        settings.AUTH_USER_MODEL, verbose_name='membre',
        related_name='loans', null=True, on_delete=models.SET_NULL)
    loan_date = models.DateTimeField(verbose_name='date de prêt')
    loan_date_end = models.DateTimeField(verbose_name='date de fin de prêt',
                                     null=True, blank=True)
    notes = models.TextField(null=True, blank=True)
    offer_subscription = models.ForeignKey(OfferSubscription, verbose_name='Abonnement',
                             related_name='loans', blank=True, null=True)

    def __unicode__(self):
        return 'prêt de {item} à {user}'.format(
            item=self.item, user=self.user)

    def get_mac_and_serial(self):
        return self.item.get_mac_and_serial()

    get_mac_and_serial.short_description = "Adresse MAC / n° de série"

    def user_can_close(self, user):
        return (not self.item.is_available()) and (self.user == user)

    def is_running(self):
        return not self.loan_date_end or self.loan_date_end > timezone.now()
    is_running.boolean = True
    is_running.short_description = 'En cours ?'

    class Meta:
        verbose_name = 'prêt d’objet'
        verbose_name_plural = 'prêts d’objets'

    objects = LoanQuerySet().as_manager()


class Storage(models.Model):
    name = models.CharField(max_length=100, verbose_name='nom')
    notes = models.TextField(
        blank=True,
        help_text='Lisible par tous les adhérents')

    def __unicode__(self):
        return self.name

    def items_count(self):
        return self.items.count()
    items_count.short_description = 'Nb. items stockés'

    class Meta:
        verbose_name = 'lieu de stockage'
        verbose_name_plural = 'lieux de stockage'