681 lines
20 KiB
Python
681 lines
20 KiB
Python
import logging
|
||
import json
|
||
from decimal import Decimal
|
||
from PIL import Image
|
||
from measurement.measures import Weight
|
||
|
||
from django.db import models
|
||
from django.db.models.functions import Coalesce
|
||
from django.conf import settings
|
||
from django.utils import timezone
|
||
from django.urls import reverse
|
||
from django.core.cache import cache
|
||
from django.core.validators import MinValueValidator, MaxValueValidator
|
||
from django.core.serializers.json import DjangoJSONEncoder
|
||
from django.contrib.postgres.fields import ArrayField, HStoreField
|
||
from django.forms.models import model_to_dict
|
||
|
||
from django_measurement.models import MeasurementField
|
||
|
||
from accounts.models import User, Address
|
||
|
||
from . import (
|
||
DiscountValueType,
|
||
VoucherType,
|
||
TransactionStatus,
|
||
OrderStatus,
|
||
ShippingStatus,
|
||
ShippingProvider,
|
||
ShippingContainer
|
||
)
|
||
from .weight import WeightUnits, zero_weight
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class SingletonBase(models.Model):
|
||
def set_cache(self):
|
||
cache.set(self.__class__.__name__, self)
|
||
|
||
def save(self, *args, **kwargs):
|
||
self.pk = 1
|
||
super(SingletonBase, self).save(*args, **kwargs)
|
||
self.set_cache()
|
||
|
||
def delete(self, *args, **kwargs):
|
||
pass
|
||
|
||
@classmethod
|
||
def load(cls):
|
||
if cache.get(cls.__name__) is None:
|
||
obj, created = cls.objects.get_or_create(pk=1)
|
||
if not created:
|
||
obj.set_cache()
|
||
return cache.get(cls.__name__)
|
||
|
||
class Meta:
|
||
abstract = True
|
||
|
||
|
||
class ProductCategory(models.Model):
|
||
name = models.CharField(max_length=255)
|
||
main_category = models.BooleanField(default=True)
|
||
|
||
def __str__(self):
|
||
return self.name
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('dashboard:category-detail', kwargs={'pk': self.pk})
|
||
|
||
class Meta:
|
||
verbose_name = 'Product Category'
|
||
verbose_name_plural = 'Product Categories'
|
||
|
||
|
||
class ProductManager(models.Manager):
|
||
def get_queryset(self):
|
||
return super().get_queryset().prefetch_related(
|
||
'productphoto_set',
|
||
'options'
|
||
)
|
||
|
||
|
||
class Product(models.Model):
|
||
category = models.ForeignKey(
|
||
ProductCategory,
|
||
blank=True,
|
||
null=True,
|
||
on_delete=models.SET_NULL
|
||
)
|
||
name = models.CharField(max_length=250)
|
||
subtitle = models.CharField(max_length=250, blank=True)
|
||
description = models.TextField(blank=True)
|
||
checkout_limit = models.IntegerField(
|
||
default=0,
|
||
validators=[MinValueValidator(0)]
|
||
)
|
||
|
||
visible_in_listings = models.BooleanField(default=False)
|
||
sorting = models.PositiveIntegerField(blank=True, null=True)
|
||
|
||
created_at = models.DateTimeField(auto_now_add=True)
|
||
updated_at = models.DateTimeField(auto_now=True)
|
||
|
||
objects = ProductManager()
|
||
|
||
def __str__(self):
|
||
return self.name
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('dashboard:product-detail', kwargs={'pk': self.pk})
|
||
|
||
def get_first_img(self):
|
||
return self.productphoto_set.first()
|
||
|
||
def get_second_img(self):
|
||
try:
|
||
return self.productphoto_set.all()[1]
|
||
except IndexError:
|
||
return 'No image'
|
||
|
||
class Meta:
|
||
ordering = ['sorting', 'name']
|
||
|
||
|
||
class ProductPhoto(models.Model):
|
||
product = models.ForeignKey(Product, on_delete=models.CASCADE)
|
||
image = models.ImageField(upload_to='products/images')
|
||
sorting = models.PositiveIntegerField(blank=True, null=True)
|
||
|
||
def __str__(self):
|
||
return f'{self.product.name} {self.image}'
|
||
|
||
def delete(self, *args, **kwargs):
|
||
storage, path = self.image.storage, self.image.path
|
||
|
||
super(ProductPhoto, self).delete(*args, **kwargs)
|
||
storage.delete(path)
|
||
|
||
class Meta:
|
||
ordering = ['sorting']
|
||
|
||
# def save(self, *args, **kwargs):
|
||
# super().save(*args, **kwargs)
|
||
|
||
# img = Image.open(self.image.path)
|
||
# if img.height > 400 or img.width > 400:
|
||
# output_size = (400, 400)
|
||
# img.thumbnail(output_size)
|
||
# img.save(self.image.path)
|
||
|
||
|
||
class ProductVariantManager(models.Manager):
|
||
def get_queryset(self):
|
||
return super().get_queryset().annotate(
|
||
num_ordered=models.Sum('order_lines__quantity')
|
||
)
|
||
|
||
|
||
class ProductVariant(models.Model):
|
||
product = models.ForeignKey(
|
||
Product,
|
||
on_delete=models.CASCADE,
|
||
related_name='variants'
|
||
)
|
||
image = models.ForeignKey(
|
||
ProductPhoto,
|
||
on_delete=models.SET_NULL,
|
||
related_name='+',
|
||
blank=True,
|
||
null=True
|
||
)
|
||
name = models.CharField(max_length=255)
|
||
sku = models.CharField(max_length=255, blank=True)
|
||
price = models.DecimalField(
|
||
max_digits=settings.DEFAULT_MAX_DIGITS,
|
||
decimal_places=settings.DEFAULT_DECIMAL_PLACES,
|
||
blank=True,
|
||
null=True,
|
||
)
|
||
weight = MeasurementField(
|
||
measurement=Weight,
|
||
unit_choices=WeightUnits.CHOICES,
|
||
default=zero_weight,
|
||
blank=True,
|
||
null=True
|
||
)
|
||
visible_in_listings = models.BooleanField(default=True)
|
||
track_inventory = models.BooleanField(default=False)
|
||
stock = models.IntegerField(
|
||
blank=True,
|
||
null=True,
|
||
validators=[MinValueValidator(0)]
|
||
)
|
||
sorting = models.PositiveIntegerField(blank=True, null=True)
|
||
order_limit = models.PositiveIntegerField(blank=True, null=True)
|
||
|
||
created_at = models.DateTimeField(auto_now_add=True)
|
||
updated_at = models.DateTimeField(auto_now=True)
|
||
|
||
#objects = ProductVariantManager()
|
||
|
||
def __str__(self):
|
||
return f'{self.product}: {self.name}'
|
||
|
||
class Meta:
|
||
ordering = ['sorting', 'weight']
|
||
|
||
|
||
class ProductOption(models.Model):
|
||
"""
|
||
Description: Consistent accross all variants
|
||
"""
|
||
products = models.ManyToManyField(
|
||
Product,
|
||
related_name='options'
|
||
)
|
||
name = models.CharField(max_length=255)
|
||
options = ArrayField(
|
||
models.CharField(max_length=255)
|
||
)
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('dashboard:option-detail', kwargs={'pk': self.pk})
|
||
|
||
def __str__(self):
|
||
return f'{self.name}'
|
||
|
||
|
||
class Coupon(models.Model):
|
||
type = models.CharField(
|
||
max_length=20,
|
||
choices=VoucherType.CHOICES,
|
||
default=VoucherType.ENTIRE_ORDER
|
||
)
|
||
name = models.CharField(max_length=255, null=True, blank=True)
|
||
code = models.CharField(max_length=12, unique=True, db_index=True)
|
||
valid_from = models.DateTimeField(default=timezone.now)
|
||
valid_to = models.DateTimeField(null=True, blank=True)
|
||
|
||
discount_value_type = models.CharField(
|
||
max_length=10,
|
||
choices=DiscountValueType.CHOICES,
|
||
default=DiscountValueType.FIXED,
|
||
)
|
||
discount_value = models.DecimalField(
|
||
max_digits=settings.DEFAULT_MAX_DIGITS,
|
||
decimal_places=settings.DEFAULT_DECIMAL_PLACES,
|
||
)
|
||
|
||
variants = models.ManyToManyField(ProductVariant, blank=True)
|
||
users = models.ManyToManyField(User, blank=True)
|
||
|
||
class Meta:
|
||
ordering = ['-valid_from', '-valid_to', 'code']
|
||
|
||
def __str__(self):
|
||
return self.name
|
||
|
||
@property
|
||
def is_valid(self):
|
||
today = timezone.localtime(timezone.now())
|
||
return True if today >= self.valid_from and today <= self.valid_to else False
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('dashboard:coupon-detail', kwargs={'pk': self.pk})
|
||
|
||
|
||
class ShippingRate(models.Model):
|
||
shipping_provider = models.CharField(
|
||
max_length=255,
|
||
choices=ShippingProvider.CHOICES,
|
||
default=ShippingProvider.USPS
|
||
)
|
||
name = models.CharField(max_length=255)
|
||
container = models.CharField(
|
||
max_length=255,
|
||
choices=ShippingContainer.CHOICES,
|
||
default=ShippingContainer.VARIABLE
|
||
)
|
||
min_order_weight = MeasurementField(
|
||
measurement=Weight,
|
||
unit_choices=WeightUnits.CHOICES,
|
||
default=zero_weight,
|
||
blank=True,
|
||
null=True
|
||
)
|
||
max_order_weight = MeasurementField(
|
||
measurement=Weight,
|
||
unit_choices=WeightUnits.CHOICES,
|
||
default=zero_weight,
|
||
blank=True,
|
||
null=True
|
||
)
|
||
is_selectable = models.BooleanField(default=True)
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('dashboard:rate-detail', kwargs={'pk': self.pk})
|
||
|
||
def __str__(self):
|
||
return f'{self.shipping_provider}: {self.name} ({self.min_order_weight}–{self.max_order_weight})'
|
||
|
||
class Meta:
|
||
ordering = ['min_order_weight']
|
||
|
||
|
||
class OrderManager(models.Manager):
|
||
def with_lines(self):
|
||
return self.select_related('lines')
|
||
|
||
def without_drafts(self):
|
||
return self.exclude(
|
||
status=OrderStatus.DRAFT
|
||
)
|
||
|
||
def with_fulfillment(self):
|
||
return self.annotate(
|
||
total_quantity_fulfilled=models.Sum('lines__quantity_fulfilled'),
|
||
total_quantity_ordered=models.Sum('lines__quantity')
|
||
)
|
||
|
||
def with_fulfillment_and_filter(self, query=None):
|
||
return self.annotate(
|
||
total_quantity_fulfilled=models.Sum('lines__quantity_fulfilled'),
|
||
total_quantity_ordered=models.Sum('lines__quantity')
|
||
).filter(pk=query)
|
||
|
||
|
||
class Order(models.Model):
|
||
customer = models.ForeignKey(
|
||
User,
|
||
related_name='orders',
|
||
on_delete=models.SET_NULL,
|
||
null=True
|
||
)
|
||
status = models.CharField(
|
||
max_length=32,
|
||
default=OrderStatus.UNFULFILLED,
|
||
choices=OrderStatus.CHOICES
|
||
)
|
||
billing_address = models.ForeignKey(
|
||
Address,
|
||
related_name="+",
|
||
editable=False,
|
||
null=True,
|
||
on_delete=models.SET_NULL
|
||
)
|
||
shipping_address = models.ForeignKey(
|
||
Address,
|
||
related_name="+",
|
||
editable=False,
|
||
null=True,
|
||
on_delete=models.SET_NULL
|
||
)
|
||
coupon = models.ForeignKey(
|
||
Coupon,
|
||
related_name='orders',
|
||
on_delete=models.SET_NULL,
|
||
blank=True,
|
||
null=True
|
||
)
|
||
subtotal_amount = models.DecimalField(
|
||
max_digits=10,
|
||
decimal_places=2,
|
||
default=0
|
||
)
|
||
coupon_amount = models.DecimalField(
|
||
max_digits=10,
|
||
decimal_places=2,
|
||
default=0
|
||
)
|
||
shipping_total = models.DecimalField(
|
||
max_digits=5,
|
||
decimal_places=2,
|
||
default=0
|
||
)
|
||
total_amount = models.DecimalField(
|
||
max_digits=10,
|
||
decimal_places=2,
|
||
default=0
|
||
)
|
||
weight = MeasurementField(
|
||
measurement=Weight,
|
||
unit_choices=WeightUnits.CHOICES,
|
||
default=zero_weight,
|
||
blank=True,
|
||
null=True
|
||
)
|
||
subscription = models.ForeignKey(
|
||
'Subscription',
|
||
related_name='orders',
|
||
editable=False,
|
||
null=True,
|
||
on_delete=models.SET_NULL
|
||
)
|
||
subscription_description = models.CharField(max_length=500, blank=True)
|
||
|
||
created_at = models.DateTimeField(auto_now_add=True, editable=False)
|
||
updated_at = models.DateTimeField(auto_now=True)
|
||
|
||
objects = OrderManager()
|
||
|
||
def get_shipping_status(self):
|
||
has_tracking = self.tracking_numbers.count() > 0
|
||
if has_tracking and self.status == OrderStatus.FULFILLED:
|
||
return ShippingStatus.SHIPPED
|
||
elif has_tracking and self.status == OrderStatus.PARTIALLY_FULFILLED:
|
||
return ShippingStatus.PARTIALLY_SHIPPED
|
||
|
||
return ShippingStatus.NOT_SHIPPED
|
||
|
||
def minus_stock(self):
|
||
for line in self.lines.all():
|
||
line.minus_stock()
|
||
|
||
def add_stock(self):
|
||
for line in self.lines.all():
|
||
line.add_stock()
|
||
|
||
def get_total_quantity(self):
|
||
return sum([line.quantity for line in self])
|
||
|
||
def get_discount(self):
|
||
if self.coupon:
|
||
if self.coupon.discount_value_type == DiscountValueType.FIXED:
|
||
return self.coupon.discount_value
|
||
elif self.coupon.discount_value_type == DiscountValueType.PERCENTAGE:
|
||
return (self.coupon.discount_value / Decimal('100')) * self.subtotal_amount
|
||
return Decimal('0')
|
||
|
||
def get_total_price_after_discount(self):
|
||
return round((self.subtotal_amount - self.get_discount()) + self.shipping_total, 2)
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('dashboard:order-detail', kwargs={'pk': self.pk})
|
||
|
||
class Meta:
|
||
ordering = ['-created_at']
|
||
permissions = [
|
||
('cancel_order', 'Can cancel order'),
|
||
]
|
||
|
||
|
||
class Transaction(models.Model):
|
||
status = models.CharField(
|
||
max_length=32,
|
||
blank=True,
|
||
default=TransactionStatus.CREATED,
|
||
choices=TransactionStatus.CHOICES
|
||
)
|
||
paypal_id = models.CharField(max_length=64, blank=True)
|
||
confirmation_email_sent = models.BooleanField(default=False)
|
||
order = models.OneToOneField(
|
||
Order,
|
||
editable=False,
|
||
blank=True,
|
||
null=True,
|
||
on_delete=models.CASCADE
|
||
)
|
||
|
||
|
||
class OrderLine(models.Model):
|
||
order = models.ForeignKey(
|
||
Order,
|
||
related_name='lines',
|
||
editable=False,
|
||
on_delete=models.CASCADE
|
||
)
|
||
product = models.ForeignKey(
|
||
Product,
|
||
related_name='order_lines',
|
||
on_delete=models.SET_NULL,
|
||
blank=True,
|
||
null=True,
|
||
)
|
||
variant = models.ForeignKey(
|
||
ProductVariant,
|
||
related_name='order_lines',
|
||
on_delete=models.SET_NULL,
|
||
blank=True,
|
||
null=True,
|
||
)
|
||
quantity = models.IntegerField(validators=[MinValueValidator(1)])
|
||
quantity_fulfilled = models.IntegerField(
|
||
validators=[MinValueValidator(0)], default=0
|
||
)
|
||
customer_note = models.TextField(blank=True, default='')
|
||
currency = models.CharField(
|
||
max_length=settings.DEFAULT_CURRENCY_CODE_LENGTH,
|
||
default=settings.DEFAULT_CURRENCY,
|
||
)
|
||
unit_price = models.DecimalField(
|
||
max_digits=settings.DEFAULT_MAX_DIGITS,
|
||
decimal_places=settings.DEFAULT_DECIMAL_PLACES,
|
||
)
|
||
|
||
def get_total(self):
|
||
return self.unit_price * self.quantity
|
||
|
||
@property
|
||
def quantity_unfulfilled(self):
|
||
return self.quantity - self.quantity_fulfilled
|
||
|
||
def minus_stock(self):
|
||
if self.variant and self.variant.track_inventory:
|
||
self.variant.stock -= self.quantity
|
||
self.variant.save()
|
||
|
||
def add_stock(self):
|
||
if self.variant and self.variant.track_inventory:
|
||
self.variant.stock += self.quantity
|
||
self.variant.save()
|
||
|
||
|
||
class TrackingNumber(models.Model):
|
||
order = models.ForeignKey(
|
||
Order,
|
||
related_name="tracking_numbers",
|
||
editable=False,
|
||
on_delete=models.CASCADE
|
||
)
|
||
tracking_id = models.CharField(max_length=256)
|
||
|
||
created_at = models.DateTimeField(auto_now_add=True, editable=False)
|
||
updated_at = models.DateTimeField(auto_now=True)
|
||
|
||
class Meta:
|
||
verbose_name = 'Tracking Number'
|
||
verbose_name_plural = 'Tracking Numbers'
|
||
|
||
def __str__(self):
|
||
return self.tracking_id
|
||
|
||
|
||
class SubscriptionManager(models.Manager):
|
||
def get_queryset(self):
|
||
return super().get_queryset().filter(is_active=True)
|
||
|
||
|
||
class Subscription(models.Model):
|
||
stripe_id = models.CharField(max_length=255, blank=True, db_index=True)
|
||
customer = models.ForeignKey(
|
||
User,
|
||
related_name='subscriptions',
|
||
on_delete=models.SET_NULL,
|
||
null=True
|
||
)
|
||
shipping_address = models.ForeignKey(
|
||
Address,
|
||
related_name='+',
|
||
editable=False,
|
||
null=True,
|
||
on_delete=models.SET_NULL
|
||
)
|
||
items = ArrayField(
|
||
models.JSONField(blank=True, null=True),
|
||
default=list
|
||
)
|
||
metadata = models.JSONField(blank=True, null=True)
|
||
is_active = models.BooleanField(default=False)
|
||
total_weight = MeasurementField(
|
||
measurement=Weight,
|
||
unit_choices=WeightUnits.CHOICES,
|
||
default=zero_weight,
|
||
blank=True,
|
||
null=True
|
||
)
|
||
|
||
created_at = models.DateTimeField(auto_now_add=True, editable=False)
|
||
updated_at = models.DateTimeField(auto_now=True)
|
||
|
||
def convert_int_to_decimal(self, price):
|
||
return Decimal(str(price)[:-2] + '.' + str(price)[-2:])
|
||
|
||
def format_product(self, data):
|
||
return {
|
||
'product': Product.objects.get(pk=data['pk']),
|
||
'quantity': data['quantity']
|
||
}
|
||
|
||
def deserialize_subscription(self, data):
|
||
subscription = {}
|
||
|
||
for x in data:
|
||
if 'Coffee' in x['description']:
|
||
subscription['unit_price'] = self.convert_int_to_decimal(x['price']['unit_amount'])
|
||
subscription['description'] = x['description']
|
||
|
||
if 'Shipping' in x['description']:
|
||
subscription['shipping_cost'] = self.convert_int_to_decimal(x['amount'])
|
||
|
||
return subscription
|
||
|
||
def create_order(self, data_object):
|
||
subscription = self.deserialize_subscription(data_object['lines']['data'])
|
||
subscription['items'] = map(self.format_product, self.metadata['products_and_quantities'])
|
||
subscription['customer_note'] = f"Grind: {self.metadata['grind']}"
|
||
|
||
order = Order.objects.create(
|
||
customer=self.customer,
|
||
status=OrderStatus.UNFULFILLED,
|
||
shipping_address=self.shipping_address,
|
||
subtotal_amount=self.convert_int_to_decimal(
|
||
data_object['subtotal']) - subscription['shipping_cost'],
|
||
shipping_total=subscription['shipping_cost'],
|
||
total_amount=self.convert_int_to_decimal(data_object['total']),
|
||
weight=self.total_weight,
|
||
subscription=self,
|
||
subscription_description=subscription['description']
|
||
)
|
||
|
||
bulk_lines = [OrderLine(
|
||
order=order,
|
||
product=item['product'],
|
||
quantity=item['quantity'],
|
||
customer_note=subscription['customer_note'],
|
||
unit_price=subscription['unit_price']
|
||
) for item in subscription['items']]
|
||
OrderLine.objects.bulk_create(bulk_lines)
|
||
|
||
def format_metadata(self):
|
||
metadata = {}
|
||
for key, value in self.metadata.items():
|
||
if 'products_and_quantities' in key:
|
||
metadata[key] = json.dumps(value)
|
||
else:
|
||
metadata[key] = value
|
||
metadata['subscription_pk'] = self.pk
|
||
return metadata
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('storefront:subscription-detail', kwargs={'pk': self.pk})
|
||
|
||
class Meta:
|
||
indexes = [
|
||
models.Index(fields=['stripe_id'])
|
||
]
|
||
|
||
|
||
class SiteSettings(SingletonBase):
|
||
usps_user_id = models.CharField(max_length=255)
|
||
default_shipping_rate = models.ForeignKey(
|
||
ShippingRate,
|
||
blank=True,
|
||
null=True,
|
||
related_name='+',
|
||
on_delete=models.SET_NULL
|
||
)
|
||
free_shipping_min = models.DecimalField(
|
||
max_digits=settings.DEFAULT_MAX_DIGITS,
|
||
decimal_places=settings.DEFAULT_DECIMAL_PLACES,
|
||
blank=True,
|
||
null=True,
|
||
help_text='Minimum dollar amount in the cart subtotal to qualify for free shipping.'
|
||
)
|
||
max_cart_quantity = models.PositiveIntegerField(
|
||
default=20,
|
||
blank=True,
|
||
null=True,
|
||
help_text='Maximum amount of items allowed in cart.'
|
||
)
|
||
max_cart_weight = MeasurementField(
|
||
measurement=Weight,
|
||
unit_choices=WeightUnits.CHOICES,
|
||
default=zero_weight,
|
||
blank=True,
|
||
null=True,
|
||
help_text='Maximum weight allowed for cart.'
|
||
)
|
||
default_contact_email = models.CharField(max_length=255, blank=True)
|
||
order_from_email = models.CharField(max_length=255, blank=True)
|
||
default_zip_origination = models.CharField(
|
||
max_length=5, blank=True, default='98368'
|
||
)
|
||
|
||
def __str__(self):
|
||
return 'Site Settings'
|
||
|
||
class Meta:
|
||
verbose_name = 'Site Settings'
|
||
verbose_name_plural = 'Site Settings'
|