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(

        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. """ # pylint: disable=no-member 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})