class Order(models.Model):
# Identification
shop = UnsavedForeignKey("Shop", on_delete=models.PROTECT)
created_on = models.DateTimeField(auto_now_add=True, editable=False)
identifier = InternalIdentifierField(unique=True,
db_index=True,
verbose_name=_('order identifier'))
# TODO: label is actually a choice field, need to check migrations/choice deconstruction
label = models.CharField(max_length=32,
db_index=True,
verbose_name=_('label'))
# The key shouldn't be possible to deduce (i.e. it should be random), but it is
# not a secret. (It could, however, be used as key material for an actual secret.)
key = models.CharField(max_length=32,
unique=True,
blank=False,
verbose_name=_('key'))
reference_number = models.CharField(max_length=64,
db_index=True,
unique=True,
blank=True,
null=True,
verbose_name=_('reference number'))
# Contact information
customer = UnsavedForeignKey("Contact",
related_name='customer_orders',
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('customer'))
orderer = UnsavedForeignKey("PersonContact",
related_name='orderer_orders',
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('orderer'))
billing_address = UnsavedForeignKey("Address",
related_name="billing_orders",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('billing address'))
shipping_address = UnsavedForeignKey("Address",
related_name='shipping_orders',
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('shipping address'))
tax_number = models.CharField(max_length=20,
blank=True,
verbose_name=_('Tax number'))
phone = models.CharField(max_length=32,
blank=True,
verbose_name=_('phone'))
email = models.EmailField(max_length=128,
blank=True,
verbose_name=_('email address'))
# Status
creator = UnsavedForeignKey(settings.AUTH_USER_MODEL,
related_name='orders_created',
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('creating user'))
deleted = models.BooleanField(db_index=True, default=False)
status = UnsavedForeignKey("OrderStatus",
verbose_name=_('status'),
on_delete=models.PROTECT)
payment_status = EnumIntegerField(PaymentStatus,
db_index=True,
default=PaymentStatus.NOT_PAID,
verbose_name=_('payment status'))
shipping_status = EnumIntegerField(ShippingStatus,
db_index=True,
default=ShippingStatus.NOT_SHIPPED,
verbose_name=_('shipping status'))
# Methods
payment_method = UnsavedForeignKey("PaymentMethod",
related_name="payment_orders",
blank=True,
null=True,
default=None,
on_delete=models.PROTECT,
verbose_name=_('payment method'))
payment_method_name = models.CharField(
max_length=64,
blank=True,
default="",
verbose_name=_('payment method name'))
payment_data = JSONField(blank=True, null=True)
shipping_method = UnsavedForeignKey("ShippingMethod",
related_name='shipping_orders',
blank=True,
null=True,
default=None,
on_delete=models.PROTECT,
verbose_name=_('shipping method'))
shipping_method_name = models.CharField(
max_length=64,
blank=True,
default="",
verbose_name=_('shipping method name'))
shipping_data = JSONField(blank=True, null=True)
extra_data = JSONField(blank=True, null=True)
# Money stuff
taxful_total_price = TaxfulPriceProperty('taxful_total_price_value',
'currency')
taxless_total_price = TaxlessPriceProperty('taxless_total_price_value',
'currency')
taxful_total_price_value = MoneyValueField(editable=False,
verbose_name=_('grand total'),
default=0)
taxless_total_price_value = MoneyValueField(
editable=False, verbose_name=_('taxless total'), default=0)
currency = CurrencyField()
prices_include_tax = models.BooleanField(
) # TODO: (TAX) Document Order.prices_include_tax
display_currency = CurrencyField(blank=True)
display_currency_rate = models.DecimalField(max_digits=36,
decimal_places=9,
default=1)
# Other
ip_address = models.GenericIPAddressField(null=True,
blank=True,
verbose_name=_('IP address'))
# order_date is not `auto_now_add` for backdating purposes
order_date = models.DateTimeField(editable=False,
verbose_name=_('order date'))
payment_date = models.DateTimeField(null=True,
editable=False,
verbose_name=_('payment date'))
# TODO: (TAX) Add me? customer_tax_group = models.ForeignKey(CustomerTaxGroup, blank=True, null=True)
language = LanguageField(blank=True, verbose_name=_('language'))
customer_comment = models.TextField(blank=True,
verbose_name=_('customer comment'))
admin_comment = models.TextField(blank=True,
verbose_name=_('admin comment/notes'))
require_verification = models.BooleanField(
default=False, verbose_name=_('requires verification'))
all_verified = models.BooleanField(default=False,
verbose_name=_('all lines verified'))
marketing_permission = models.BooleanField(
default=True, verbose_name=_('marketing permission'))
common_select_related = ("billing_address", )
objects = OrderQuerySet.as_manager()
class Meta:
ordering = ("-id", )
verbose_name = _('order')
verbose_name_plural = _('orders')
def __str__(self): # pragma: no cover
if self.billing_address_id:
name = self.billing_address.name
else:
name = "-"
if settings.SHOOP_ENABLE_MULTIPLE_SHOPS:
return "Order %s (%s, %s)" % (self.identifier, self.shop.name,
name)
else:
return "Order %s (%s)" % (self.identifier, name)
def cache_prices(self):
taxful_total = TaxfulPrice(0, self.currency)
taxless_total = TaxlessPrice(0, self.currency)
for line in self.lines.all():
taxful_total += line.taxful_total_price
taxless_total += line.taxless_total_price
self.taxful_total_price = _round_price(taxful_total)
self.taxless_total_price = _round_price(taxless_total)
def _cache_contact_values(self):
sources = [
self.shipping_address,
self.billing_address,
self.customer,
self.orderer,
]
fields = ("tax_number", "email", "phone")
for field in fields:
if getattr(self, field, None):
continue
for source in sources:
val = getattr(source, field, None)
if val:
setattr(self, field, val)
break
def _cache_values(self):
self._cache_contact_values()
if not self.label:
self.label = settings.SHOOP_DEFAULT_ORDER_LABEL
if not self.currency:
self.currency = self.shop.currency
if not self.prices_include_tax:
self.prices_include_tax = self.shop.prices_include_tax
if not self.display_currency:
self.display_currency = self.currency
self.display_currency_rate = 1
if self.shipping_method_id and not self.shipping_method_name:
self.shipping_method_name = self.shipping_method.safe_translation_getter(
"name",
default=self.shipping_method.identifier,
any_language=True)
if self.payment_method_id and not self.payment_method_name:
self.payment_method_name = self.payment_method.safe_translation_getter(
"name",
default=self.payment_method.identifier,
any_language=True)
if not self.key:
self.key = get_random_string(32)
def _save_identifiers(self):
self.identifier = "%s" % (get_order_identifier(self))
self.reference_number = get_reference_number(self)
super(Order, self).save(update_fields=(
"identifier",
"reference_number",
))
def full_clean(self, exclude=None, validate_unique=True):
self._cache_values()
return super(Order, self).full_clean(exclude, validate_unique)
def create_immutable_address_copies(self):
for field in ("billing_address", "shipping_address"):
address = getattr(self, field, None)
if address and not address.is_immutable:
if address.pk:
address = address.copy()
address.set_immutable()
else:
address.set_immutable()
setattr(self, field, address)
def save(self, *args, **kwargs):
if not self.creator_id:
if not settings.SHOOP_ALLOW_ANONYMOUS_ORDERS:
raise ValidationError(
"Anonymous (userless) orders are not allowed "
"when SHOOP_ALLOW_ANONYMOUS_ORDERS is not enabled.")
self._cache_values()
first_save = (not self.pk)
self.create_immutable_address_copies()
super(Order, self).save(*args, **kwargs)
if first_save: # Have to do a double save the first time around to be able to save identifiers
self._save_identifiers()
def delete(self, using=None):
if not self.deleted:
self.deleted = True
self.add_log_entry("Deleted.", kind=LogEntryKind.DELETION)
# Bypassing local `save()` on purpose.
super(Order, self).save(update_fields=("deleted", ), using=using)
def set_canceled(self):
if self.status.role != OrderStatusRole.CANCELED:
self.status = OrderStatus.objects.get_default_canceled()
self.save()
def _set_paid(self):
if self.payment_status != PaymentStatus.FULLY_PAID: # pragma: no branch
self.add_log_entry(_('Order marked as paid.'))
self.payment_status = PaymentStatus.FULLY_PAID
self.payment_date = now()
self.save()
def is_paid(self):
return (self.payment_status == PaymentStatus.FULLY_PAID)
def get_total_paid_amount(self):
amounts = self.payments.values_list('amount_value', flat=True)
return Money(sum(amounts, Decimal(0)), self.currency)
def create_payment(self, amount, payment_identifier=None, description=''):
"""
Create a payment with given amount for this order.
If the order already has payments and sum of their amounts is
equal or greater than self.taxful_total_price, an exception is raised.
If the end sum of all payments is equal or greater than
self.taxful_total_price, then the order is marked as paid.
:param amount:
Amount of the payment to be created
:type amount: Money
:param payment_identifier:
Identifier of the created payment. If not set, default value
of "gateway_id:order_id:number" will be used (where number is
number of payments in the order).
:type payment_identifier: str|None
:param description:
Description of the payment. Will be set to `method` property
of the created payment.
:type description: str
:returns: The created Payment object
:rtype: shoop.core.models.Payment
"""
assert isinstance(amount, Money)
assert amount.currency == self.currency
payments = self.payments.order_by('created_on')
total_paid_amount = self.get_total_paid_amount()
if total_paid_amount >= self.taxful_total_price.amount:
raise NoPaymentToCreateException(
"Order %s has already been fully paid (%s >= %s)." %
(self.pk, total_paid_amount, self.taxful_total_price))
if not payment_identifier:
number = payments.count() + 1
payment_identifier = '%d:%d' % (self.id, number)
payment = self.payments.create(
payment_identifier=payment_identifier,
amount_value=amount.value,
description=description,
)
if self.get_total_paid_amount() >= self.taxful_total_price.amount:
self._set_paid() # also calls save
return payment
def create_shipment(self, supplier, product_quantities):
"""
Create a shipment for this order from `product_quantities`.
`product_quantities` is expected to be a dict mapping Product instances to quantities.
Only quantities over 0 are taken into account, and if the mapping is empty or has no quantity value
over 0, `NoProductsToShipException` will be raised.
:param supplier: The Supplier for this product. No validation is made
as to whether the given supplier supplies the products.
:param product_quantities: a dict mapping Product instances to quantities to ship
:type product_quantities: dict[shoop.shop.models.products.Product, decimal.Decimal]
:raises: NoProductsToShipException
:return: Saved, complete Shipment object
:rtype: shoop.core.models.shipments.Shipment
"""
if not product_quantities or not any(
quantity > 0 for quantity in product_quantities.values()):
raise NoProductsToShipException(
"No products to ship (`quantities` is empty or has no quantity over 0)."
)
from .shipments import Shipment, ShipmentProduct
shipment = Shipment(order=self, supplier=supplier)
shipment.save()
for product, quantity in product_quantities.items():
if quantity > 0:
sp = ShipmentProduct(shipment=shipment,
product=product,
quantity=quantity)
sp.cache_values()
sp.save()
shipment.cache_values()
shipment.save()
self.add_log_entry(_(u"Shipment #%d created.") % shipment.id)
self.check_and_set_fully_shipped()
return shipment
def create_shipment_of_all_products(self, supplier=None):
"""
Create a shipment of all the products in this Order, no matter whether or not any have been previously
marked as shipped or not.
See the documentation for `create_shipment`.
:param supplier: The Supplier to use. If `None`, the first supplier in
the order is used. (If several are in the order, this fails.)
:return: Saved, complete Shipment object
:rtype: shoop.shop.models.shipments.Shipment
"""
suppliers_to_product_quantities = defaultdict(
lambda: defaultdict(lambda: 0))
lines = (self.lines.filter(type=OrderLineType.PRODUCT).values_list(
"supplier_id", "product_id", "quantity"))
for supplier_id, product_id, quantity in lines:
if product_id:
suppliers_to_product_quantities[supplier_id][
product_id] += quantity
if not suppliers_to_product_quantities:
raise NoProductsToShipException(
"Could not find any products to ship.")
if supplier is None:
if len(suppliers_to_product_quantities) > 1: # pragma: no cover
raise ValueError(
"Can only use create_shipment_of_all_products when there is only one supplier"
)
supplier_id, quantities = suppliers_to_product_quantities.popitem()
supplier = Supplier.objects.get(pk=supplier_id)
else:
quantities = suppliers_to_product_quantities[supplier.id]
products = dict(
(product.pk, product)
for product in Product.objects.filter(pk__in=quantities.keys()))
quantities = dict((products[product_id], quantity)
for (product_id, quantity) in quantities.items())
return self.create_shipment(supplier, quantities)
def check_all_verified(self):
if not self.all_verified:
new_all_verified = (not self.lines.filter(verified=False).exists())
if new_all_verified:
self.all_verified = True
if self.require_verification:
self.add_log_entry(
_('All rows requiring verification have been verified.'
))
self.require_verification = False
self.save()
return self.all_verified
def get_purchased_attachments(self):
from .product_media import ProductMedia
if self.payment_status != PaymentStatus.FULLY_PAID:
return ProductMedia.objects.none()
prods = self.lines.exclude(product=None).values_list("product_id",
flat=True)
return ProductMedia.objects.filter(product__in=prods,
enabled=True,
purchased=True)
def get_tax_summary(self):
"""
:rtype: taxing.TaxSummary
"""
all_line_taxes = []
untaxed = TaxlessPrice(0, self.currency)
for line in self.lines.all():
line_taxes = list(line.taxes.all())
all_line_taxes.extend(line_taxes)
if not line_taxes:
untaxed += line.taxless_total_price
return taxing.TaxSummary.from_line_taxes(all_line_taxes, untaxed)
def get_product_ids_and_quantities(self):
quantities = defaultdict(lambda: 0)
for product_id, quantity in self.lines.filter(
type=OrderLineType.PRODUCT).values_list(
"product_id", "quantity"):
quantities[product_id] += quantity
return dict(quantities)
def is_complete(self):
return (self.status.role == OrderStatusRole.COMPLETE)
def can_set_complete(self):
fully_shipped = (self.shipping_status == ShippingStatus.FULLY_SHIPPED)
canceled = (self.status.role == OrderStatusRole.CANCELED)
return (not self.is_complete()) and fully_shipped and (not canceled)
def check_and_set_fully_shipped(self):
if self.shipping_status != ShippingStatus.FULLY_SHIPPED:
if not self.get_unshipped_products():
self.shipping_status = ShippingStatus.FULLY_SHIPPED
self.add_log_entry(
_(u"All products have been shipped. Fully Shipped status set."
))
self.save(update_fields=("shipping_status", ))
return True
def get_known_additional_data(self):
"""
Get a list of "known additional data" in this order's payment_data, shipping_data and extra_data.
The list is returned in the order the fields are specified in the settings entries for said known keys.
`dict(that_list)` can of course be used to "flatten" the list into a dict.
:return: list of 2-tuples.
"""
output = []
for data_dict, name_mapping in (
(self.payment_data, settings.SHOOP_ORDER_KNOWN_PAYMENT_DATA_KEYS),
(self.shipping_data,
settings.SHOOP_ORDER_KNOWN_SHIPPING_DATA_KEYS),
(self.extra_data, settings.SHOOP_ORDER_KNOWN_EXTRA_DATA_KEYS),
):
if hasattr(data_dict, "get"):
for key, display_name in name_mapping:
if key in data_dict:
output.append(
(force_text(display_name), data_dict[key]))
return output
def get_product_summary(self):
"""Return a dict of product IDs -> {ordered, unshipped, shipped}"""
products = defaultdict(lambda: defaultdict(lambda: Decimal(0)))
lines = (self.lines.filter(type=OrderLineType.PRODUCT).values_list(
"product_id", "quantity"))
for product_id, quantity in lines:
products[product_id]['ordered'] += quantity
products[product_id]['unshipped'] += quantity
from .shipments import ShipmentProduct
shipment_prods = (ShipmentProduct.objects.filter(
shipment__order=self).values_list("product_id", "quantity"))
for product_id, quantity in shipment_prods:
products[product_id]['shipped'] += quantity
products[product_id]['unshipped'] -= quantity
return products
def get_unshipped_products(self):
return dict(
(product, summary_datum)
for product, summary_datum in self.get_product_summary().items()
if summary_datum['unshipped'])
def get_status_display(self):
return force_text(self.status)
class OrderLine(MoneyPropped, models.Model, Priceful):
order = UnsavedForeignKey("Order",
related_name='lines',
on_delete=models.PROTECT,
verbose_name=_('order'))
product = UnsavedForeignKey("Product",
blank=True,
null=True,
related_name="order_lines",
on_delete=models.PROTECT,
verbose_name=_('product'))
supplier = UnsavedForeignKey("Supplier",
blank=True,
null=True,
related_name="order_lines",
on_delete=models.PROTECT,
verbose_name=_('supplier'))
parent_line = UnsavedForeignKey("self",
related_name="child_lines",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('parent line'))
ordering = models.IntegerField(default=0, verbose_name=_('ordering'))
type = EnumIntegerField(OrderLineType,
default=OrderLineType.PRODUCT,
verbose_name=_('line type'))
sku = models.CharField(max_length=48,
blank=True,
verbose_name=_('line SKU'))
text = models.CharField(max_length=256, verbose_name=_('line text'))
accounting_identifier = models.CharField(
max_length=32, blank=True, verbose_name=_('accounting identifier'))
require_verification = models.BooleanField(
default=False, verbose_name=_('require verification'))
verified = models.BooleanField(default=False, verbose_name=_('verified'))
extra_data = JSONField(blank=True, null=True, verbose_name=_('extra data'))
# The following fields govern calculation of the prices
quantity = QuantityField(verbose_name=_('quantity'), default=1)
base_unit_price = PriceProperty('base_unit_price_value', 'order.currency',
'order.prices_include_tax')
discount_amount = PriceProperty('discount_amount_value', 'order.currency',
'order.prices_include_tax')
base_unit_price_value = MoneyValueField(
verbose_name=_('unit price amount (undiscounted)'), default=0)
discount_amount_value = MoneyValueField(
verbose_name=_('total amount of discount'), default=0)
objects = OrderLineManager()
class Meta:
verbose_name = _('order line')
verbose_name_plural = _('order lines')
def __str__(self):
return "%dx %s (%s)" % (self.quantity, self.text,
self.get_type_display())
@property
def tax_amount(self):
"""
:rtype: shoop.utils.money.Money
"""
zero = Money(0, self.order.currency)
return sum((x.amount for x in self.taxes.all()), zero)
def save(self, *args, **kwargs):
if not self.sku:
self.sku = u""
if self.type == OrderLineType.PRODUCT and not self.product_id:
raise ValidationError(
"Product-type order line can not be saved without a set product"
)
if self.product_id and self.type != OrderLineType.PRODUCT:
raise ValidationError(
"Order line has product but is not of Product type")
if self.product_id and not self.supplier_id:
raise ValidationError("Order line has product but no supplier")
super(OrderLine, self).save(*args, **kwargs)
if self.product_id:
self.supplier.module.update_stock(self.product_id)
class ShopProduct(MoneyPropped, models.Model):
shop = models.ForeignKey("Shop",
related_name="shop_products",
on_delete=models.CASCADE)
product = UnsavedForeignKey("Product",
related_name="shop_products",
on_delete=models.CASCADE)
suppliers = models.ManyToManyField("Supplier",
related_name="shop_products",
blank=True)
visible = models.BooleanField(default=True, db_index=True)
listed = models.BooleanField(default=True, db_index=True)
purchasable = models.BooleanField(default=True, db_index=True)
searchable = models.BooleanField(default=True, db_index=True)
visibility_limit = EnumIntegerField(
ProductVisibility,
db_index=True,
default=ProductVisibility.VISIBLE_TO_ALL,
verbose_name=_('visibility limitations'))
visibility_groups = models.ManyToManyField(
"ContactGroup",
related_name='visible_products',
verbose_name=_('visible for groups'),
blank=True)
purchase_multiple = QuantityField(default=0,
verbose_name=_('purchase multiple'))
minimum_purchase_quantity = QuantityField(
default=1, verbose_name=_('minimum purchase'))
limit_shipping_methods = models.BooleanField(default=False)
limit_payment_methods = models.BooleanField(default=False)
shipping_methods = models.ManyToManyField(
"ShippingMethod",
related_name='shipping_products',
verbose_name=_('shipping methods'),
blank=True)
payment_methods = models.ManyToManyField("PaymentMethod",
related_name='payment_products',
verbose_name=_('payment methods'),
blank=True)
primary_category = models.ForeignKey("Category",
related_name='primary_shop_products',
verbose_name=_('primary category'),
blank=True,
null=True,
on_delete=models.PROTECT)
categories = models.ManyToManyField("Category",
related_name='shop_products',
verbose_name=_('categories'),
blank=True)
shop_primary_image = models.ForeignKey(
"ProductMedia",
null=True,
blank=True,
related_name="primary_image_for_shop_products",
on_delete=models.SET_NULL)
# the default price of this product in the shop
default_price = PriceProperty('default_price_value', 'shop.currency',
'shop.prices_include_tax')
default_price_value = MoneyValueField(verbose_name=_("Default price"),
null=True,
blank=True)
class Meta:
unique_together = ((
"shop",
"product",
), )
def is_list_visible(self):
"""
Return True if this product should be visible in listings in general,
without taking into account any other visibility limitations.
:rtype: bool
"""
if self.product.deleted:
return False
if not self.visible:
return False
if not self.listed:
return False
if self.product.is_variation_child():
return False
return True
@property
def primary_image(self):
if self.shop_primary_image_id:
return self.shop_primary_image
else:
return self.product.primary_image
def get_visibility_errors(self, customer):
if self.product.deleted:
yield ValidationError(_('This product has been deleted.'),
code="product_deleted")
if customer and customer.is_all_seeing: # None of the further conditions matter for omniscient customers.
return
if not self.visible:
yield ValidationError(_('This product is not visible.'),
code="product_not_visible")
is_logged_in = (bool(customer) and not customer.is_anonymous)
if not is_logged_in and self.visibility_limit != ProductVisibility.VISIBLE_TO_ALL:
yield ValidationError(
_('The Product is invisible to users not logged in.'),
code="product_not_visible_to_anonymous")
if is_logged_in and self.visibility_limit == ProductVisibility.VISIBLE_TO_GROUPS:
# TODO: Optimization
user_groups = set(customer.groups.all().values_list("pk",
flat=True))
my_groups = set(self.visibility_groups.values_list("pk",
flat=True))
if not bool(user_groups & my_groups):
yield ValidationError(
_('This product is not visible to your group.'),
code="product_not_visible_to_group")
for receiver, response in get_visibility_errors.send(
ShopProduct, shop_product=self, customer=customer):
for error in response:
yield error
# TODO: Refactor get_orderability_errors, it's too complex
def get_orderability_errors( # noqa (C901)
self,
supplier,
quantity,
customer,
ignore_minimum=False):
"""
Yield ValidationErrors that would cause this product to not be orderable.
:param supplier: Supplier to order this product from. May be None.
:type supplier: shoop.core.models.suppliers.Supplier
:param quantity: Quantity to order.
:type quantity: int|Decimal
:param customer: Customer contact.
:type customer: shoop.core.models.Contact
:param ignore_minimum: Ignore any limitations caused by quantity minimums.
:type ignore_minimum: bool
:return: Iterable[ValidationError]
"""
for error in self.get_visibility_errors(customer):
yield error
if supplier is None and not self.suppliers.exists():
# `ShopProduct` must have at least one `Supplier`.
# If supplier is not given and the `ShopProduct` itself
# doesn't have suppliers we cannot sell this product.
yield ValidationError(_('The product has no supplier.'),
code="no_supplier")
if not ignore_minimum and quantity < self.minimum_purchase_quantity:
yield ValidationError(_(
'The purchase quantity needs to be at least %d for this product.'
) % self.minimum_purchase_quantity,
code="purchase_quantity_not_met")
if supplier and not self.suppliers.filter(pk=supplier.pk).exists():
yield ValidationError(_('The product is not supplied by %s.') %
supplier,
code="invalid_supplier")
if self.product.is_package_parent():
for child_product, child_quantity in six.iteritems(
self.product.get_package_child_to_quantity_map()):
child_shop_product = child_product.get_shop_instance(
shop=self.shop)
if not child_shop_product:
yield ValidationError("%s: Not available in %s" %
(child_product, self.shop),
code="invalid_shop")
for error in child_shop_product.get_orderability_errors(
supplier=supplier,
quantity=(quantity * child_quantity),
customer=customer,
ignore_minimum=ignore_minimum):
code = getattr(error, "code", None)
yield ValidationError("%s: %s" % (child_product, error),
code=code)
if supplier and self.product.stock_behavior == StockBehavior.STOCKED:
for error in supplier.get_orderability_errors(self,
quantity,
customer=customer):
yield error
purchase_multiple = self.purchase_multiple
if quantity > 0 and purchase_multiple > 1 and (quantity %
purchase_multiple) != 0:
p = (quantity // purchase_multiple)
smaller_p = max(purchase_multiple, p * purchase_multiple)
larger_p = max(purchase_multiple, (p + 1) * purchase_multiple)
if larger_p == smaller_p:
message = _(
'The product can only be ordered in multiples of %(package_size)s, '
'for example %(smaller_p)s %(unit)s.') % {
"package_size": purchase_multiple,
"smaller_p": smaller_p,
"unit": self.product.sales_unit,
}
else:
message = _(
'The product can only be ordered in multiples of %(package_size)s, '
'for example %(smaller_p)s or %(larger_p)s %(unit)s.') % {
"package_size": purchase_multiple,
"smaller_p": smaller_p,
"larger_p": larger_p,
"unit": self.product.sales_unit,
}
yield ValidationError(message, code="invalid_purchase_multiple")
for receiver, response in get_orderability_errors.send(
ShopProduct,
shop_product=self,
customer=customer,
supplier=supplier,
quantity=quantity):
for error in response:
yield error
def raise_if_not_orderable(self,
supplier,
customer,
quantity,
ignore_minimum=False):
for message in self.get_orderability_errors(
supplier=supplier,
quantity=quantity,
customer=customer,
ignore_minimum=ignore_minimum):
raise ProductNotOrderableProblem(message.args[0])
def raise_if_not_visible(self, customer):
for message in self.get_visibility_errors(customer=customer):
raise ProductNotVisibleProblem(message.args[0])
def is_orderable(self, supplier, customer, quantity):
for message in self.get_orderability_errors(supplier=supplier,
quantity=quantity,
customer=customer):
return False
return True
@property
def quantity_step(self):
"""
Quantity step for purchasing this product.
:rtype: decimal.Decimal
Example:
<input type="number" step="{{ shop_product.quantity_step }}">
"""
if self.purchase_multiple:
return self.purchase_multiple
return self.product.sales_unit.quantity_step
@property
def rounded_minimum_purchase_quantity(self):
"""
The minimum purchase quantity, rounded to the sales unit's precision.
:rtype: decimal.Decimal
Example:
<input type="number"
min="{{ shop_product.rounded_minimum_purchase_quantity }}"
value="{{ shop_product.rounded_minimum_purchase_quantity }}">
"""
return self.product.sales_unit.round(self.minimum_purchase_quantity)
@property
def images(self):
return self.product.media.filter(
shops=self.shop, kind=ProductMediaKind.IMAGE).order_by("ordering")
class OrderLine(models.Model, LinePriceMixin):
order = UnsavedForeignKey("Order",
related_name='lines',
on_delete=models.PROTECT,
verbose_name=_('order'))
product = UnsavedForeignKey("Product",
blank=True,
null=True,
related_name="order_lines",
on_delete=models.PROTECT,
verbose_name=_('product'))
supplier = UnsavedForeignKey("Supplier",
blank=True,
null=True,
related_name="order_lines",
on_delete=models.PROTECT,
verbose_name=_('supplier'))
parent_line = UnsavedForeignKey("self",
related_name="child_lines",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_('parent line'))
ordering = models.IntegerField(default=0, verbose_name=_('ordering'))
type = EnumIntegerField(OrderLineType,
default=OrderLineType.PRODUCT,
verbose_name=_('line type'))
sku = models.CharField(max_length=48,
blank=True,
verbose_name=_('line SKU'))
text = models.CharField(max_length=256, verbose_name=_('line text'))
accounting_identifier = models.CharField(
max_length=32, blank=True, verbose_name=_('accounting identifier'))
require_verification = models.BooleanField(
default=False, verbose_name=_('require verification'))
verified = models.BooleanField(default=False, verbose_name=_('verified'))
extra_data = JSONField(blank=True, null=True)
# The following fields govern calculation of the prices
quantity = QuantityField(verbose_name=_('quantity'), default=1)
_unit_price_amount = MoneyField(verbose_name=_('unit price amount'))
_total_discount_amount = MoneyField(
verbose_name=_('total amount of discount'))
_prices_include_tax = models.BooleanField(default=True)
objects = OrderLineManager()
class Meta:
verbose_name = _('order line')
verbose_name_plural = _('order lines')
def __str__(self):
return "%dx %s (%s)" % (self.quantity, self.text,
self.get_type_display())
@property
def unit_price(self):
"""
Unit price of OrderLine.
:rtype: Price
"""
if self._prices_include_tax:
return TaxfulPrice(self._unit_price_amount)
else:
return TaxlessPrice(self._unit_price_amount)
@unit_price.setter
def unit_price(self, price):
"""
Set unit price of OrderLine.
:type price: TaxfulPrice|TaxlessPrice
"""
self._check_input_price(price)
self._unit_price_amount = price.amount
self._prices_include_tax = price.includes_tax
@property
def total_discount(self):
"""
Total discount of OrderLine.
:rtype: Price
"""
if self._prices_include_tax:
return TaxfulPrice(self._total_discount_amount)
else:
return TaxlessPrice(self._total_discount_amount)
@total_discount.setter
def total_discount(self, discount):
"""
Set total discount of OrderLine.
:type discount: TaxfulPrice|TaxlessPrice
"""
self._check_input_price(discount)
self._total_discount_amount = discount.amount
self._prices_include_tax = discount.includes_tax
@property
def total_tax_amount(self):
"""
:rtype: decimal.Decimal
"""
return sum((x.amount for x in self.taxes.all()), decimal.Decimal(0))
def _check_input_price(self, price):
if not isinstance(price, Price):
raise TypeError('%r is not a Price object' % (price, ))
if self._unit_price_amount or self._total_discount_amount:
if price.includes_tax != self._prices_include_tax:
tp = TaxfulPrice if self._prices_include_tax else TaxlessPrice
msg = 'Cannot accept %r because we want a %s'
raise TypeError(msg % (price, tp.__name__))
def save(self, *args, **kwargs):
if not self.sku:
self.sku = u""
if self.type == OrderLineType.PRODUCT and not self.product_id:
raise ValidationError(
"Product-type order line can not be saved without a set product"
)
if self.product_id and self.type != OrderLineType.PRODUCT:
raise ValidationError(
"Order line has product but is not of Product type")
if self.product_id and not self.supplier_id:
raise ValidationError("Order line has product but no supplier")
return super(OrderLine, self).save(*args, **kwargs)