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.exceptions import ObjectDoesNotExist
from django.core.validators import RegexValidator
from django.db import models, transaction
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 = models.ForeignKey('referral.Referral',
    #                              verbose_name=_('Referral code'),
    #                              on_delete=models.DO_NOTHING,
    #                              blank=True, null=True,
    #                              related_name='ref_code')
    referral_user = models.ForeignKey('self',
                                      verbose_name=_('Referral user'),
                                      on_delete=models.DO_NOTHING,
                                      blank=True, null=True,
                                      related_name='ref_user')

    confirmed_at = models.DateTimeField(_('email confirmed at'), 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)
    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(_('patronymic'), max_length=100, blank=True, null=True)
    birthday = models.DateField(_('birthday'), 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_STATUS_LEGAL = 25
COMPANY_STATUS_INDIVIDUAL = 50
COMPANY_STATUS_LIST = (
    (COMPANY_STATUS_INDIVIDUAL, _("Legal")),
    (COMPANY_STATUS_INDIVIDUAL, _("Individual"))
)

#@TODO: translate into english and use translation
class Company(AbstractStatusModel):
    user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE)
    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)
    status = models.SmallIntegerField(choices=COMPANY_STATUS_LIST, blank=True, null=True)

    @property
    def is_individual(self):
        return self.status == COMPANY_STATUS_INDIVIDUAL

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

    def __str__(self):
        return self.company_name

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


class PickUpRequest(models.Model):
    user = models.ForeignKey(User, 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 = 'PickUpRequest'
        verbose_name_plural = 'PickUpRequests'

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


@receiver(post_save, sender=get_user_model())
def save_user_profile(sender, instance, **kwargs):
    try:
        instance.profile.save()
    except ObjectDoesNotExist:
        Profile.objects.create(user=instance)


@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()