Source code for oscar.apps.customer.abstract_models

from django.contrib.auth import models as auth_models
from django.core.mail import send_mail
from django.db import models
from django.urls import reverse
from django.utils import timezone
from django.utils.crypto import get_random_string
from django.utils.translation import gettext_lazy as _

from oscar.core.compat import AUTH_USER_MODEL

class UserManager(auth_models.BaseUserManager):

    def create_user(self, email, password=None, **extra_fields):
        Creates and saves a User with the given email and
        now =
        if not email:
            raise ValueError('The given email must be set')
        email = UserManager.normalize_email(email)
        user = self.model(
            email=email, is_staff=False, is_active=True,
            last_login=now, date_joined=now, **extra_fields)

        return user

    def create_superuser(self, email, password, **extra_fields):
        u = self.create_user(email, password, **extra_fields)
        u.is_staff = True
        u.is_active = True
        u.is_superuser = True
        return u

[docs]class AbstractUser(auth_models.AbstractBaseUser, auth_models.PermissionsMixin): """ An abstract base user suitable for use in Oscar projects. This is basically a copy of the core AbstractUser model but without a username field """ email = models.EmailField(_('email address'), unique=True) first_name = models.CharField( _('First name'), max_length=255, blank=True) last_name = models.CharField( _('Last name'), max_length=255, blank=True) is_staff = models.BooleanField( _('Staff status'), default=False, help_text=_('Designates whether the user can log into this admin ' 'site.')) is_active = models.BooleanField( _('Active'), default=True, help_text=_('Designates whether this user should be treated as ' 'active. Unselect this instead of deleting accounts.')) date_joined = models.DateTimeField(_('date joined'), objects = UserManager() USERNAME_FIELD = 'email' class Meta: abstract = True verbose_name = _('User') verbose_name_plural = _('Users')
[docs] def clean(self): super().clean() = self.__class__.objects.normalize_email(
[docs] def get_full_name(self): """ Return the first_name plus the last_name, with a space in between. """ full_name = '%s %s' % (self.first_name, self.last_name) return full_name.strip()
[docs] def get_short_name(self): """ Return the short name for the user. """ return self.first_name
[docs] def email_user(self, subject, message, from_email=None, **kwargs): """ Send an email to this user. """ send_mail(subject, message, from_email, [], **kwargs)
def _migrate_alerts_to_user(self): """ Transfer any active alerts linked to a user's email address to the newly registered user. """ ProductAlert = self.alerts.model alerts = ProductAlert.objects.filter(, status=ProductAlert.ACTIVE) alerts.update(user=self, key='', email='')
[docs] def save(self, *args, **kwargs): super().save(*args, **kwargs) # Migrate any "anonymous" product alerts to the registered user # Ideally, this would be done via a post-save signal. But we can't # use get_user_model to wire up signals to custom user models # see Oscar ticket #1127, Django ticket #19218 self._migrate_alerts_to_user()
[docs]class AbstractProductAlert(models.Model): """ An alert for when a product comes back in stock """ product = models.ForeignKey( 'catalogue.Product', on_delete=models.CASCADE) # A user is only required if the notification is created by a # registered user, anonymous users will only have an email address # attached to the notification user = models.ForeignKey( AUTH_USER_MODEL, blank=True, null=True, on_delete=models.CASCADE, related_name="alerts", verbose_name=_('User')) email = models.EmailField(_("Email"), db_index=True, blank=True) # This key are used to confirm and cancel alerts for anon users key = models.CharField(_("Key"), max_length=128, blank=True, db_index=True) # An alert can have two different statuses for authenticated # users ``ACTIVE`` and ``CANCELLED`` and anonymous users have an # additional status ``UNCONFIRMED``. For anonymous users a confirmation # and unsubscription key are generated when an instance is saved for # the first time and can be used to confirm and unsubscribe the # notifications. UNCONFIRMED, ACTIVE, CANCELLED, CLOSED = ( 'Unconfirmed', 'Active', 'Cancelled', 'Closed') STATUS_CHOICES = ( (UNCONFIRMED, _('Not yet confirmed')), (ACTIVE, _('Active')), (CANCELLED, _('Cancelled')), (CLOSED, _('Closed')), ) status = models.CharField(_("Status"), max_length=20, choices=STATUS_CHOICES, default=ACTIVE) date_created = models.DateTimeField(_("Date created"), auto_now_add=True, db_index=True) date_confirmed = models.DateTimeField(_("Date confirmed"), blank=True, null=True) date_cancelled = models.DateTimeField(_("Date cancelled"), blank=True, null=True) date_closed = models.DateTimeField(_("Date closed"), blank=True, null=True) class Meta: abstract = True app_label = 'customer' ordering = ['-date_created'] verbose_name = _('Product alert') verbose_name_plural = _('Product alerts') @property def is_anonymous(self): return self.user is None @property def can_be_confirmed(self): return self.status == self.UNCONFIRMED @property def can_be_cancelled(self): return self.status in (self.ACTIVE, self.UNCONFIRMED) @property def is_cancelled(self): return self.status == self.CANCELLED @property def is_active(self): return self.status == self.ACTIVE def confirm(self): self.status = self.ACTIVE self.date_confirmed = confirm.alters_data = True def cancel(self): self.status = self.CANCELLED self.date_cancelled = cancel.alters_data = True def close(self): self.status = self.CLOSED self.date_closed = close.alters_data = True def get_email_address(self): if self.user: return else: return
[docs] def save(self, *args, **kwargs): if not and not self.user: self.key = self.get_random_key() self.status = self.UNCONFIRMED # Ensure date fields get updated when saving from modelform (which just # calls save, and doesn't call the methods cancel(), confirm() etc). if self.status == self.CANCELLED and self.date_cancelled is None: self.date_cancelled = if not self.user and self.status == self.ACTIVE \ and self.date_confirmed is None: self.date_confirmed = if self.status == self.CLOSED and self.date_closed is None: self.date_closed = return super().save(*args, **kwargs)
def get_random_key(self): return get_random_string(length=40, allowed_chars='abcdefghijklmnopqrstuvwxyz0123456789') def get_confirm_url(self): return reverse('customer:alerts-confirm', kwargs={'key': self.key}) def get_cancel_url(self): return reverse('customer:alerts-cancel-by-key', kwargs={'key': self.key})