Codice sorgente per thx.core.models

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

'''
Db Mixins
============

Per semplificare la creazione dei nostri modelli e per renderla più omogenea sono
stati creati dei mixin astratti (``Meta:  abstract=True``) che aggiungono campi e
funzionalità (vedi in particolare :class:`CleanModel`):

* :class:`UserModel` (``creator``, ``last_modifier``)
* :class:`DateModel` (``date_create``, ``date_last_modify``)
* :class:`StatusModel` (``status``)
* :class:`OrderedModel` (``ordering``)
* :class:`SEOModel` (``meta_description``, ``page_title``, ``meta_keywords``)
* :class:`CleanModel` (sovrascive ``.save()``)

Esempio
--------

::

  class PriceList(CleanModel, UserModel, DateModel, StatusModel, OrderedModel):
      """
      Price List belongs to Stores, not to Suppliers. A supplier can have different PriceList for
      different Stores
      """
      objects = models.Manager()
      available = managers.AvailablePriceListManager()

      code = models.CharField(
          max_length=100,
          verbose_name=_('code'),
      )
      ...

Modelli
========

.. autoclass:: UserModel
   :members:

.. autoclass:: DateModel
   :members:

.. autoclass:: StatusModel
   :members:

.. autoclass:: OrderedModel
   :members:

.. autoclass:: SEOModel
   :members:

.. autoclass:: CleanModel
   :members:

'''
from __future__ import unicode_literals

from django.db import models
from django.conf import settings
from django.utils.timezone import datetime
from django.utils.translation import ugettext_lazy as _


class UserModel(models.Model):
    """
    **UserModel** è una classe *abstract* che estende django.db.models.Model.

    Alla classe erede vengono aggiunti due attributi entrambi di tipo settings.AUTH_USER_MODEL:

    :creator: indica l'utente che ha creato il record; una volta inserito non dovrà più essere aggiornato;
    :last_modifier: indica l'ultimo utente in ordine temporale che ha modificato il record

    Entrambe le FK sono definite on_delete=models.PROTECT
    """

    creator = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.PROTECT,
        related_name="%(app_label)s_%(class)s_creator",
        verbose_name=_("creator"),
    )
    last_modifier = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.PROTECT,
        related_name='%(app_label)s_%(class)s_last_modifier',
        verbose_name=_("last modifier"),
    )

    class Meta:
        abstract = True


class DateModel(models.Model):
    """
    **DateModel** è una classe *abstract* che estende django.db.models.Model.

    Alla classe erede vengono aggiunti due attributi entrambi di tipo settings.DateTimeField:

    :date_create: indica il datetime di creazione; viene valorizzato in modo automatico durante la creazione del record non verrà più aggiornato

    :date_last_modify: indica il datetime di ultima modifica; viene valorizzato ad ogni salvataggio con il datetime corrente

    """

    date_create = models.DateTimeField(
        auto_now_add=True,
        verbose_name=_('date create'),
    )
    date_last_modify = models.DateTimeField(
        auto_now=True,
        verbose_name=_('date last modify'),
    )

    class Meta:
        abstract = True


class StatusModel(models.Model):
    """
    **StatusModel** è una classe *abstract* che estende django.db.models.Model.

    Alla classe erede viene aggiunto un attributo:

    - status: indica se un record è enable o disable e i valori sono limitati dal settings STATUS_CODES; viene utilizzato per la cancellazione logica di un record
    """

    STATUS_CODES = (
        (0, _('disable')),
        (1, _('enable')),
    )
    status = models.IntegerField(
        choices=STATUS_CODES,
        default=1,
        verbose_name=_('status'),
        null=True
    )

    class Meta:
        abstract = True


class OrderedModel(models.Model):
    """
    **OrderedModel** è una classe *abstract* che estende django.db.models.Model.

    Alla classe erede viene aggiunto un attributo:

    - ordering: serve per dare una posizione fissa al record nell'ordine del queryset
    """

    ordering = models.IntegerField(
        default=0,
        verbose_name=_('ordering'),
    )

    class Meta:
        abstract = True


class SEOModel(models.Model):
    """
    **SEOModel** è una classe *abstract* che estende django.db.models.Model.

    Alla classe erede vengono aggiunti tre attributi che possono essere utilizzati per il SEO
    """

    meta_description = models.TextField(
        _("description"),
        max_length=255,
        blank=True,
    )
    meta_keywords = models.CharField(
        _("keywords"),
        max_length=255,
        blank=True,
    )
    page_title = models.CharField(
        _("title"),
        max_length=255,
        help_text=_("overwrite the title (html title tag)"),
        blank=True,
    )

    class Meta:
        abstract = True


class CleanModel(models.Model):
    """
    **CleanModel** è una classe *abstract* che estende django.db.models.Model.

    viene ridefinita la funzione 'save' nella quale viene richiamata la full_clean (chiama tutte le clean() in cascata)
    per validare gli attributi del record prima della 'save' effettiva
    """

    class Meta:
        abstract = True

    def save(self, *args, **kwargs):
        self.full_clean()
        super().save(*args, **kwargs)