mybuddy/core/models.py

# -*- coding: utf-8 -*-
from datetime import timedelta

from django.conf import settings
from django.core.exceptions import ValidationError
from django.db import models
from django.template.defaultfilters import slugify
from django.utils import timezone
from django.utils.text import format_lazy
from django.utils.translation import gettext_lazy as _


def validate_date(date, field_name):
    """
    Confirm that a date is not in the future.
    :param date: a timezone aware date instance.
    :param field_name: the name of the field being checked.
    :return:
    """
    if date and date > timezone.localdate():
        raise ValidationError(
            {field_name: _('Date can not be in the future.')},
            code='date_invalid')


def validate_duration(model, max_duration=timedelta(hours=24)):
    """
    Basic sanity checks for models with a duration
    :param model: a model instance with 'start' and 'end' attributes
    :param max_duration: maximum allowed duration between start and end time
    :return:
    """
    if model.start and model.end:
        if model.start > model.end:
            raise ValidationError(
                _('Start time must come before end time.'),
                code='end_before_start')
        if model.end - model.start > max_duration:
            raise ValidationError(_('Duration too long.'), code='max_duration')


def validate_unique_period(queryset, model):
    """
    Confirm that model's start and end date do not intersect with other
    instances.
    :param queryset: a queryset of instances to check against.
    :param model: a model instance with 'start' and 'end' attributes
    :return:
    """
    if model.id:
        queryset = queryset.exclude(id=model.id)
    if model.start and model.end:
        if queryset.filter(start__lte=model.end, end__gte=model.start):
            raise ValidationError(
                _('Another entry intersects the specified time period.'),
                code='period_intersection')


def validate_time(time, field_name):
    """
    Confirm that a time is not in the future.
    :param time: a timezone aware datetime instance.
    :param field_name: the name of the field being checked.
    :return:
    """
    if time and time > timezone.localtime():
        raise ValidationError(
            {field_name: _('Date/time can not be in the future.')},
            code='time_invalid')


class Child(models.Model):
    model_name = 'child'
    first_name = models.CharField(max_length=255, verbose_name=_('First name'))
    last_name = models.CharField(max_length=255, verbose_name=_('Last name'))
    birth_date = models.DateField(
        blank=False,
        null=False,
        verbose_name=_('Birth date')
    )
    slug = models.SlugField(
        editable=False,
        max_length=100,
        unique=True,
        verbose_name=_('Slug')
    )
    picture = models.ImageField(
        blank=True,
        null=True,
        upload_to='child/picture/',
        verbose_name=_('Picture')
    )

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['last_name', 'first_name']
        verbose_name = _('Child')
        verbose_name_plural = _('Children')

    def __str__(self):
        return '{} {}'.format(self.first_name, self.last_name)

    def save(self, *args, **kwargs):
        self.slug = slugify(self)
        super(Child, self).save(*args, **kwargs)

    def name(self, reverse=False):
        if reverse:
            return '{}, {}'.format(self.last_name, self.first_name)

        return '{} {}'.format(self.first_name, self.last_name)


class DiaperChange(models.Model):
    model_name = 'diaperchange'
    child = models.ForeignKey(
        'Child',
        on_delete=models.CASCADE,
        related_name='diaper_change',
        verbose_name=_('Child')
    )
    time = models.DateTimeField(blank=False, null=False, verbose_name=_('Time'))
    wet = models.BooleanField(verbose_name=_('Wet'))
    solid = models.BooleanField(verbose_name=_('Solid'))
    color = models.CharField(
        blank=True,
        choices=[
            ('black', _('Black')),
            ('brown', _('Brown')),
            ('green', _('Green')),
            ('yellow', _('Yellow')),
        ],
        max_length=255,
        verbose_name=_('Color')
    )

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-time']
        verbose_name = _('Diaper Change')
        verbose_name_plural = _('Diaper Changes')

    def __str__(self):
        return str(_('Diaper Change'))

    def attributes(self):
        attributes = []
        if self.wet:
            attributes.append(DiaperChange._meta.get_field('wet').name)
        if self.solid:
            attributes.append(DiaperChange._meta.get_field('solid').name)
        if self.color:
            attributes.append(self.color)
        return attributes

    def clean(self):
        validate_time(self.time, 'time')

        # One or both of Wet and Solid is required.
        if not self.wet and not self.solid:
            raise ValidationError(
                _('Wet and/or solid is required.'), code='wet_or_solid')


class Feeding(models.Model):
    model_name = 'feeding'
    child = models.ForeignKey(
        'Child',
        on_delete=models.CASCADE,
        related_name='feeding',
        verbose_name=_('Child')
    )
    start = models.DateTimeField(
        blank=False,
        null=False,
        verbose_name=_('Start time')
    )
    end = models.DateTimeField(
        blank=False,
        null=False,
        verbose_name=_('End time')
    )
    duration = models.DurationField(
        editable=False,
        null=True,
        verbose_name=_('Duration')
    )
    type = models.CharField(
        choices=[('breast milk', _('Breast milk')), ('formula', _('Formula'))],
        max_length=255,
        verbose_name=_('Type')
    )
    method = models.CharField(
        choices=[
            ('bottle', _('Bottle')),
            ('left breast', _('Left breast')),
            ('right breast', _('Right breast')),
        ],
        max_length=255,
        verbose_name=_('Method')
    )
    amount = models.FloatField(blank=True, null=True, verbose_name=_('Amount'))

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-start']
        verbose_name = _('Feeding')
        verbose_name_plural = _('Feedings')

    def __str__(self):
        return str(_('Feeding'))

    def save(self, *args, **kwargs):
        if self.start and self.end:
            self.duration = self.end - self.start
        super(Feeding, self).save(*args, **kwargs)

    def clean(self):
        validate_time(self.start, 'start')
        validate_time(self.end, 'end')
        validate_duration(self)
        validate_unique_period(Feeding.objects.filter(child=self.child), self)

        # "Formula" Type may only be associated with "Bottle" Method.
        if self.type == 'formula'and self.method != 'bottle':
            raise ValidationError(
                {'method':
                 _('Only "Bottle" method is allowed with "Formula" type.')},
                code='bottle_formula_mismatch')


class Note(models.Model):
    model_name = 'note'
    child = models.ForeignKey(
        'Child',
        on_delete=models.CASCADE,
        related_name='note',
        verbose_name=_('Child')
    )
    note = models.TextField(verbose_name=_('Note'))
    time = models.DateTimeField(auto_now=True, verbose_name=_('Time'))

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-time']
        verbose_name = _('Note')
        verbose_name_plural = _('Notes')

    def __str__(self):
        return str(_('Note'))


class NapsManager(models.Manager):
    def get_queryset(self):
        qs = super(NapsManager, self).get_queryset()
        return qs.filter(id__in=[obj.id for obj in qs if obj.nap])


class Sleep(models.Model):
    model_name = 'sleep'
    child = models.ForeignKey(
        'Child',
        on_delete=models.CASCADE,
        related_name='sleep',
        verbose_name=_('Child')
    )
    start = models.DateTimeField(
        blank=False,
        null=False,
        verbose_name=_('Start time')
    )
    end = models.DateTimeField(
        blank=False,
        null=False,
        verbose_name=_('End time')
    )
    duration = models.DurationField(
        editable=False,
        null=True,
        verbose_name=_('Duration')
    )

    objects = models.Manager()
    naps = NapsManager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-start']
        verbose_name = _('Sleep')
        verbose_name_plural = _('Sleep')

    def __str__(self):
        return str(_('Sleep'))

    @property
    def nap(self):
        nap_start_min = timezone.datetime.strptime(
            settings.BABY_BUDDY['NAP_START_MIN'], '%H:%M').time()
        nap_start_max = timezone.datetime.strptime(
            settings.BABY_BUDDY['NAP_START_MAX'], '%H:%M').time()
        local_start_time = timezone.localtime(self.start).time()
        return nap_start_min <= local_start_time <= nap_start_max

    def save(self, *args, **kwargs):
        if self.start and self.end:
            self.duration = self.end - self.start
        super(Sleep, self).save(*args, **kwargs)

    def clean(self):
        validate_time(self.start, 'start')
        validate_time(self.end, 'end')
        validate_duration(self)
        validate_unique_period(Sleep.objects.filter(child=self.child), self)


class Timer(models.Model):
    model_name = 'timer'
    name = models.CharField(
        blank=True,
        max_length=255,
        null=True,
        verbose_name=_('Name')
    )
    start = models.DateTimeField(
        default=timezone.now,
        blank=False,
        verbose_name=_('Start time')
    )
    end = models.DateTimeField(
        blank=True,
        editable=False,
        null=True,
        verbose_name=_('End time')
    )
    duration = models.DurationField(
        editable=False,
        null=True,
        verbose_name=_('Duration')
    )
    active = models.BooleanField(
        default=True,
        editable=False,
        verbose_name=_('Active')
    )
    user = models.ForeignKey(
        'auth.User',
        on_delete=models.CASCADE,
        related_name='timers',
        verbose_name=_('User')
    )

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-active', '-start', '-end']
        verbose_name = _('Timer')
        verbose_name_plural = _('Timers')

    def __str__(self):
        return self.name or str(format_lazy(_('Timer #{id}'), id=self.id))

    @classmethod
    def from_db(cls, db, field_names, values):
        instance = super(Timer, cls).from_db(db, field_names, values)
        if not instance.duration:
            instance.duration = timezone.now() - instance.start
        return instance

    def restart(self):
        """Restart the timer."""
        self.start = timezone.now()
        self.end = None
        self.duration = None
        self.active = True
        self.save()

    def stop(self, end=None):
        """Stop the timer."""
        if not self.end:
            end = timezone.now()
        self.end = end
        self.save()

    def save(self, *args, **kwargs):
        self.active = self.end is None
        self.name = self.name or None
        if self.start and self.end:
            self.duration = self.end - self.start
        else:
            self.duration = None
        super(Timer, self).save(*args, **kwargs)

    def clean(self):
        validate_time(self.start, 'start')
        if self.end:
            validate_time(self.end, 'end')
        validate_duration(self)


class TummyTime(models.Model):
    model_name = 'tummytime'
    child = models.ForeignKey(
        'Child',
        on_delete=models.CASCADE,
        related_name='tummy_time',
        verbose_name=_('Child')
    )
    start = models.DateTimeField(
        blank=False,
        null=False,
        verbose_name=_('Start time')
    )
    end = models.DateTimeField(
        blank=False,
        null=False,
        verbose_name=_('End time')
    )
    duration = models.DurationField(
        editable=False,
        null=True,
        verbose_name=_('Duration')
    )
    milestone = models.CharField(
        blank=True,
        max_length=255,
        verbose_name=_('Milestone')
    )

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-start']
        verbose_name = _('Tummy Time')
        verbose_name_plural = _('Tummy Time')

    def __str__(self):
        return str(_('Tummy Time'))

    def save(self, *args, **kwargs):
        if self.start and self.end:
            self.duration = self.end - self.start
        super(TummyTime, self).save(*args, **kwargs)

    def clean(self):
        validate_time(self.start, 'start')
        validate_time(self.end, 'end')
        validate_duration(self)
        validate_unique_period(
            TummyTime.objects.filter(child=self.child), self)


class Weight(models.Model):
    model_name = 'weight'
    child = models.ForeignKey(
        'Child',
        on_delete=models.CASCADE,
        related_name='weight',
        verbose_name=_('Child')
    )
    weight = models.FloatField(
        blank=False,
        null=False,
        verbose_name=_('Weight')
    )
    date = models.DateField(
        blank=False,
        null=False,
        verbose_name=_('Date')
    )

    objects = models.Manager()

    class Meta:
        default_permissions = ('view', 'add', 'change', 'delete')
        ordering = ['-date']
        verbose_name = _('Weight')
        verbose_name_plural = _('Weight')

    def __str__(self):
        return str(_('Weight'))

    def clean(self):
        validate_date(self.date, 'date')