SoftwareShop/accounts_ext/models.py

from django.contrib.auth import get_user_model
from django.contrib.auth.models import (
    Group as GroupBase, AbstractBaseUser, BaseUserManager, PermissionsMixin
)
from django.core.validators import RegexValidator
from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils.translation import ugettext_lazy as _
from django.utils.timezone import now as datetime_now

from registration.signals import user_activated

from core.models import AbstractStatusModel, ActualOnlyManager, STATUS_ACTIVE


# Create your models here.

class CaseInsensitiveQuerySet(models.QuerySet):
    CASE_INSENSITIVE_FIELDS = ('email',)

    def _filter_or_exclude(self, negate, *args, **kwargs):
        for field in self.CASE_INSENSITIVE_FIELDS:
            if field in kwargs:
                kwargs[field + '__iexact'] = kwargs[field]
                del kwargs[field]
        return super()._filter_or_exclude(negate, *args, **kwargs)


class UserManager(ActualOnlyManager, BaseUserManager):
    def create_superuser(self, email, password):
        user = self.model(
            email=email,
            is_superuser=True,
            status=STATUS_ACTIVE,
        )
        user.set_password(password)
        user.save(using=self._db)
        return user

    def get_queryset(self):
        return CaseInsensitiveQuerySet(self.model)


# @TODO: translate into english and use translation
class User(AbstractStatusModel, PermissionsMixin, AbstractBaseUser):
    username = models.CharField(_('username'), max_length=255, blank=False, null=False)
    email = models.EmailField(
        _('email'),
        unique=True,
        error_messages={
            'unique': _("A user with that email already exists."),
        },
    )

    referral_user = models.ForeignKey('self',
                                      verbose_name=_('Реферальный пользователь'),
                                      on_delete=models.SET_NULL,
                                      blank=True, null=True
                                      )

    confirmed_at = models.DateTimeField(_('подвтержден в'), blank=True, null=True)

    USERNAME_FIELD = 'email'

    objects = UserManager()

    @property
    def is_staff(self):
        return self.is_superuser

    @property
    def date_joined(self):
        return self.create_at

    @date_joined.setter
    def date_joined(self, value):
        self.create_at = value

    def get_short_name(self):
        return self.email

    class Meta:
        verbose_name = _('пользователь')
        verbose_name_plural = _('пользователи')


# @TODO: translate into english and use translation
class Group(GroupBase):
    class Meta:
        proxy = True
        verbose_name = _('группа')
        verbose_name_plural = _('группы')


# @TODO: translate into english and use translation
class Profile(AbstractStatusModel):
    user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE, verbose_name=_('username'))
    first_name = models.CharField(_('first name'), max_length=100, blank=True, null=True)
    last_name = models.CharField(_('last name'), max_length=100, blank=True, null=True)
    patronymic = models.CharField(_('отчество'), max_length=100, blank=True, null=True)
    birthday = models.DateField(_('дата рождения'), null=True, blank=True)

    phone_regex = RegexValidator(regex=r'^\((+7)|8)?\d{10}$',
                                 message="Phone number must be entered in the format: '+99999999999'. Up to 12 digits allowed.")
    phone = models.CharField(_('телефон'),validators=[phone_regex], max_length=12, blank=True, null=True)

    @property
    def is_valid(self):
        return self.first_name and self.last_name and self.patronymic

    @property
    def is_complete(self):
        return self.first_name and self.last_name and self.patronymic and self.birthday

    class Meta:
        verbose_name = _('профиль')
        verbose_name_plural = _('профили')

    def __str__(self):
        return str(self.user)


COMPANY_TYPE_LEGAL = 25
COMPANY_TYPE_INDIVIDUAL = 50
COMPANY_TYPE_CHOICES = (
    (COMPANY_TYPE_LEGAL, _("Компания")),
    (COMPANY_TYPE_INDIVIDUAL, _("Физ лицо"))
)
COMPANY_TYPE_DEFAULT_CHOICE = COMPANY_TYPE_LEGAL


# @TODO: translate into english and use translation
class Company(AbstractStatusModel):
    user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE, verbose_name=_('username'))
    company_name = models.CharField(_('компания'), max_length=255, blank=True, null=True)
    address = models.TextField(_('адрес'), blank=True, null=True)
    inn = models.CharField(_('ИНН'), max_length=12, blank=True, null=True)
    ogrn = models.CharField(_('ОГРН'), max_length=13, blank=True, null=True)
    type = models.SmallIntegerField(_('тип'), choices=COMPANY_TYPE_CHOICES, default=COMPANY_TYPE_DEFAULT_CHOICE,
                                    blank=True, null=True)

    def set_company_type(self, is_individual_type_predicate):
        return COMPANY_TYPE_INDIVIDUAL if is_individual_type_predicate else COMPANY_TYPE_LEGAL

    @property
    def is_individual(self):
        return self.type == COMPANY_TYPE_INDIVIDUAL

    @property
    def is_legal(self):
        return self.status == COMPANY_TYPE_LEGAL

    def __str__(self):
        return self.company_name or ''

    class Meta:
        verbose_name = _('компания')
        verbose_name_plural = _('компании')


class UserPoints(models.Model):
    user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE, null=True)
    points = models.DecimalField(max_digits=8, decimal_places=2, null=True, default=0.00)
    requisites = models.CharField(max_length=256, default='')

    def __str__(self):
        return str(self.user.id)

    class Meta:
        verbose_name = _('очки пользователя')
        verbose_name_plural = _('очки пользователя')


@receiver(post_save, sender=get_user_model())
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance).save()
        Company.objects.create(user=instance).save()

@receiver(user_activated)
def save_activation_date(sender, user, request, **kwargs):
    user.confirmed_at = datetime_now()
    user.is_active = user.status == STATUS_ACTIVE
    user.save()