class OrderLine(LineWithUnit, AbstractOrderLine):
order = UnsavedForeignKey("Order", related_name='lines', on_delete=models.PROTECT, verbose_name=_('order'))
# TODO: Store the display and sales unit to OrderLine
@property
def shop(self):
return self.order.shop
class ShopProduct(MoneyPropped, models.Model):
shop = models.ForeignKey("Shop",
related_name="shop_products",
on_delete=models.CASCADE,
verbose_name=_("shop"))
product = UnsavedForeignKey("Product",
related_name="shop_products",
on_delete=models.CASCADE,
verbose_name=_("product"))
suppliers = models.ManyToManyField(
"Supplier",
related_name="shop_products",
blank=True,
verbose_name=_("suppliers"),
help_text=
_("List your suppliers here. Suppliers can be found in Product Settings - Suppliers."
))
visibility = EnumIntegerField(
ShopProductVisibility,
default=ShopProductVisibility.ALWAYS_VISIBLE,
db_index=True,
verbose_name=_("visibility"),
help_text=mark_safe_lazy(
_("Select if you want your product to be seen and found by customers. "
"<p>Not visible: Product will not be shown in your store front or found in search.</p>"
"<p>Searchable: Product will be shown in search but not listed on any category page.</p>"
"<p>Listed: Product will be shown on category pages but not shown in search results.</p>"
"<p>Always Visible: Product will be shown in your store front and found in search.</p>"
)))
purchasable = models.BooleanField(default=True,
db_index=True,
verbose_name=_("purchasable"))
visibility_limit = EnumIntegerField(
ProductVisibility,
db_index=True,
default=ProductVisibility.VISIBLE_TO_ALL,
verbose_name=_('visibility limitations'),
help_text=
_("Select whether you want your product to have special limitations on its visibility in your store. "
"You can make products visible to all, visible to only logged in users, or visible only to certain "
"customer groups."))
visibility_groups = models.ManyToManyField(
"ContactGroup",
related_name='visible_products',
verbose_name=_('visible for groups'),
blank=True,
help_text=
_(u"Select the groups you would like to make your product visible for. "
u"These groups are defined in Contacts Settings - Contact Groups."))
backorder_maximum = QuantityField(
default=0,
blank=True,
null=True,
verbose_name=_('backorder maximum'),
help_text=_(
"The number of units that can be purchased after the product is out of stock. "
"Set to blank for product to be purchasable without limits."))
purchase_multiple = QuantityField(
default=0,
verbose_name=_('purchase multiple'),
help_text=_(
"Set this if the product needs to be purchased in multiples. "
"For example, if the purchase multiple is set to 2, then customers are required to order the product "
"in multiples of 2."))
minimum_purchase_quantity = QuantityField(
default=1,
verbose_name=_('minimum purchase'),
help_text=_(
"Set a minimum number of products needed to be ordered for the purchase. "
"This is useful for setting bulk orders and B2B purchases."))
limit_shipping_methods = models.BooleanField(
default=False,
verbose_name=_("limited for shipping methods"),
help_text=_(
"Check this if you want to limit your product to use only select payment methods. "
"You can select the payment method(s) in the field below."))
limit_payment_methods = models.BooleanField(
default=False,
verbose_name=_("limited for payment methods"),
help_text=_(
"Check this if you want to limit your product to use only select payment methods. "
"You can select the payment method(s) in the field below."))
shipping_methods = models.ManyToManyField(
"ShippingMethod",
related_name='shipping_products',
verbose_name=_('shipping methods'),
blank=True,
help_text=_(
"Select the shipping methods you would like to limit the product to using. "
"These are defined in Settings - Shipping Methods."))
payment_methods = models.ManyToManyField(
"PaymentMethod",
related_name='payment_products',
verbose_name=_('payment methods'),
blank=True,
help_text=_(
"Select the payment methods you would like to limit the product to using. "
"These are defined in Settings - Payment Methods."))
primary_category = models.ForeignKey(
"Category",
related_name='primary_shop_products',
verbose_name=_('primary category'),
blank=True,
null=True,
on_delete=models.PROTECT,
help_text=_(
"Choose the primary category for your product. "
"This will be the main category for classification in the system. "
"Your product can be found under this category in your store. "
"Categories are defined in Products Settings - Categories."))
categories = models.ManyToManyField(
"Category",
related_name='shop_products',
verbose_name=_('categories'),
blank=True,
help_text=_(
"Add secondary categories for your product. "
"These are other categories that your product fits under and that it can be found by in your store."
))
shop_primary_image = models.ForeignKey(
"ProductMedia",
null=True,
blank=True,
related_name="primary_image_for_shop_products",
on_delete=models.SET_NULL,
verbose_name=_("primary image"),
help_text=
_("Click this to set this image as the primary display image for your product."
))
# 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,
help_text=_(
"This is the default individual base unit (or multi-pack) price of the product. "
"All discounts or coupons will be based off of this price."))
minimum_price = PriceProperty('minimum_price_value', 'shop.currency',
'shop.prices_include_tax')
minimum_price_value = MoneyValueField(
verbose_name=_("minimum price"),
null=True,
blank=True,
help_text=
_("This is the default price that the product cannot go under in your store, "
"despite coupons or discounts being applied. "
"This is useful to make sure your product price stays above cost."))
display_unit = models.ForeignKey(
DisplayUnit,
null=True,
blank=True,
verbose_name=_("display unit"),
help_text=_("Unit for displaying quantities of this product"))
class Meta:
unique_together = ((
"shop",
"product",
), )
def save(self, *args, **kwargs):
self.clean()
super(ShopProduct, self).save(*args, **kwargs)
for supplier in self.suppliers.all():
supplier.module.update_stock(product_id=self.product.id)
def clean(self):
super(ShopProduct, self).clean()
if self.display_unit:
if self.display_unit.internal_unit != self.product.sales_unit:
raise ValidationError({
'display_unit':
_("Invalid display unit: Internal unit of "
"the selected display unit does not match "
"with the sales unit of the 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.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
@property
def searchable(self):
return self.visibility in (ShopProductVisibility.SEARCHABLE,
ShopProductVisibility.ALWAYS_VISIBLE)
@property
def listed(self):
return self.visibility in (ShopProductVisibility.LISTED,
ShopProductVisibility.ALWAYS_VISIBLE)
@property
def visible(self):
return not (self.visibility == ShopProductVisibility.NOT_VISIBLE)
@property
def public_primary_image(self):
primary_image = self.primary_image
return primary_image if primary_image and primary_image.public else None
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: shuup.core.models.Supplier
:param quantity: Quantity to order.
:type quantity: int|Decimal
:param customer: Customer contact.
:type customer: shuup.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.mode == ProductMode.SIMPLE_VARIATION_PARENT:
sellable = False
for child_product in self.product.variation_children.all():
child_shop_product = child_product.get_shop_instance(self.shop)
if child_shop_product.is_orderable(
supplier=supplier,
customer=customer,
quantity=child_shop_product.minimum_purchase_quantity,
allow_cache=False):
sellable = True
break
if not sellable:
yield ValidationError(_("Product has no sellable children"),
code="no_sellable_children")
elif self.product.mode == ProductMode.VARIABLE_VARIATION_PARENT:
from shuup.core.models import ProductVariationResult
sellable = False
for combo in self.product.get_all_available_combinations():
res = ProductVariationResult.resolve(
self.product, combo["variable_to_value"])
if not res:
continue
child_shop_product = res.get_shop_instance(self.shop)
if child_shop_product.is_orderable(
supplier=supplier,
customer=customer,
quantity=child_shop_product.minimum_purchase_quantity,
allow_cache=False):
sellable = True
break
if not sellable:
yield ValidationError(_("Product has no sellable children"),
code="no_sellable_children")
if self.product.is_package_parent():
for child_product, child_quantity in six.iteritems(
self.product.get_package_child_to_quantity_map()):
try:
child_shop_product = child_product.get_shop_instance(
shop=self.shop, allow_cache=False)
except ShopProduct.DoesNotExist:
yield ValidationError("%s: Not available in %s" %
(child_product, self.shop),
code="invalid_shop")
else:
for error in child_shop_product.get_orderability_errors(
supplier=supplier,
quantity=(quantity * child_quantity),
customer=customer,
ignore_minimum=ignore_minimum):
message = getattr(error, "message", "")
code = getattr(error, "code", None)
yield ValidationError("%s: %s" %
(child_product, message),
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 > 0 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)
render_qty = self.unit.render_quantity
if larger_p == smaller_p:
message = _("The product can only be ordered in multiples of "
"{package_size}, for example {amount}").format(
package_size=render_qty(purchase_multiple),
amount=render_qty(smaller_p))
else:
message = _("The product can only be ordered in multiples of "
"{package_size}, for example {smaller_amount} or "
"{larger_amount}").format(
package_size=render_qty(purchase_multiple),
smaller_amount=render_qty(smaller_p),
larger_amount=render_qty(larger_p))
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, allow_cache=True):
key, val = context_cache.get_cached_value(
identifier="is_orderable",
item=self,
context={"customer": customer},
supplier=supplier,
quantity=quantity,
allow_cache=allow_cache)
if customer and val is not None:
return val
if not supplier:
supplier = self.suppliers.first() # TODO: Allow multiple suppliers
for message in self.get_orderability_errors(supplier=supplier,
quantity=quantity,
customer=customer):
if customer:
context_cache.set_cached_value(key, False)
return False
if customer:
context_cache.set_cached_value(key, True)
return True
def is_visible(self, customer):
for message in self.get_visibility_errors(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 }}">
"""
step = self.purchase_multiple or self._sales_unit.quantity_step
return self._sales_unit.round(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._sales_unit.round(self.minimum_purchase_quantity)
@property
def display_quantity_step(self):
"""
Quantity step of this shop product in the display unit.
Note: This can never be smaller than the display precision.
"""
return max(self.unit.to_display(self.quantity_step),
self.unit.display_precision)
@property
def display_quantity_minimum(self):
"""
Quantity minimum of this shop product in the display unit.
Note: This can never be smaller than the display precision.
"""
return max(self.unit.to_display(self.minimum_purchase_quantity),
self.unit.display_precision)
@property
def unit(self):
"""
Unit of this product.
:rtype: shuup.core.models.UnitInterface
"""
return UnitInterface(self._sales_unit, self.display_unit)
@property
def _sales_unit(self):
return self.product.sales_unit or PiecesSalesUnit()
@property
def images(self):
return self.product.media.filter(
shops=self.shop, kind=ProductMediaKind.IMAGE).order_by("ordering")
@property
def public_images(self):
return self.images.filter(public=True)
class AbstractOrderLine(MoneyPropped, models.Model, Priceful):
product = UnsavedForeignKey(
"shuup.Product", blank=True, null=True, related_name="order_lines",
on_delete=models.PROTECT, verbose_name=_('product')
)
supplier = UnsavedForeignKey(
"shuup.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'))
labels = models.ManyToManyField("Label", blank=True, verbose_name=_("labels"))
# 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)
created_on = models.DateTimeField(auto_now_add=True, editable=False, db_index=True, verbose_name=_('created on'))
modified_on = models.DateTimeField(
default=timezone.now, editable=False, db_index=True, verbose_name=_('modified on')
)
objects = OrderLineManager()
class Meta:
verbose_name = _('order line')
verbose_name_plural = _('order lines')
abstract = True
def __str__(self):
return "%dx %s (%s)" % (self.quantity, self.text, self.get_type_display())
@property
def tax_amount(self):
"""
:rtype: shuup.utils.money.Money
"""
zero = Money(0, self.order.currency)
return sum((x.amount for x in self.taxes.all()), zero)
@property
def max_refundable_amount(self):
"""
:rtype: shuup.utils.money.Money
"""
refunds = self.child_lines.refunds().filter(parent_line=self)
refund_total_value = sum(refund.taxful_price.amount.value for refund in refunds)
return (self.taxful_price.amount + Money(refund_total_value, self.order.currency))
@property
def max_refundable_quantity(self):
if self.type == OrderLineType.REFUND:
return 0
return self.quantity - self.refunded_quantity
@property
def refunded_quantity(self):
return (
self.child_lines.filter(type=OrderLineType.REFUND).aggregate(total=Sum("quantity"))["total"] or 0
)
@property
def shipped_quantity(self):
if not self.product:
return 0
return ShipmentProduct.objects.filter(
shipment__supplier=self.supplier.id,
product_id=self.product.id,
shipment__order=self.order
).aggregate(total=Sum("quantity"))["total"] or 0
def save(self, *args, **kwargs):
if not self.sku:
self.sku = u""
if self.type == OrderLineType.PRODUCT and not self.product_id:
raise ValidationError("Error! Product-type order line can not be saved without a set product.")
if self.product_id and self.type != OrderLineType.PRODUCT:
raise ValidationError("Error! Order line has product but is not of Product-type.")
if self.product_id and not self.supplier_id:
raise ValidationError("Error! Order line has product, but no supplier.")
super(AbstractOrderLine, self).save(*args, **kwargs)
if self.product_id:
self.supplier.module.update_stock(self.product_id)
class Order(MoneyPropped, models.Model):
# Identification
shop = UnsavedForeignKey("Shop",
on_delete=models.PROTECT,
verbose_name=_("shop"))
created_on = models.DateTimeField(auto_now_add=True,
editable=False,
db_index=True,
verbose_name=_("created on"))
modified_on = models.DateTimeField(auto_now=True,
editable=False,
db_index=True,
verbose_name=_("modified on"))
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 = models.ForeignKey(
"ImmutableAddress",
related_name="billing_orders",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_("billing address"),
)
shipping_address = models.ForeignKey(
"ImmutableAddress",
related_name="shipping_orders",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_("shipping address"),
)
tax_number = models.CharField(max_length=64,
blank=True,
verbose_name=_("tax number"))
phone = models.CharField(max_length=64,
blank=True,
verbose_name=_("phone"))
email = models.EmailField(max_length=128,
blank=True,
verbose_name=_("email address"))
# Customer related information that might change after order, but is important
# for accounting and/or reports later.
account_manager = models.ForeignKey("PersonContact",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_("account manager"))
customer_groups = models.ManyToManyField(
"ContactGroup",
related_name="customer_group_orders",
verbose_name=_("customer groups"),
blank=True)
tax_group = models.ForeignKey("CustomerTaxGroup",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_("tax group"))
# Status
creator = UnsavedForeignKey(
settings.AUTH_USER_MODEL,
related_name="orders_created",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_("creating user"),
)
modified_by = UnsavedForeignKey(
settings.AUTH_USER_MODEL,
related_name="orders_modified",
blank=True,
null=True,
on_delete=models.PROTECT,
verbose_name=_("modifier user"),
)
deleted = models.BooleanField(db_index=True,
default=False,
verbose_name=_("deleted"))
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=100,
blank=True,
default="",
verbose_name=_("payment method name"))
payment_data = JSONField(blank=True,
null=True,
verbose_name=_("payment data"))
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=100,
blank=True,
default="",
verbose_name=_("shipping method name"))
shipping_data = JSONField(blank=True,
null=True,
verbose_name=_("shipping data"))
extra_data = JSONField(blank=True, null=True, verbose_name=_("extra data"))
# 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(verbose_name=_("currency"))
prices_include_tax = models.BooleanField(
verbose_name=_("prices include tax"))
display_currency = CurrencyField(blank=True,
verbose_name=_("display currency"))
display_currency_rate = models.DecimalField(
max_digits=36,
decimal_places=9,
default=1,
verbose_name=_("display currency rate"))
# 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,
db_index=True,
verbose_name=_("order date"))
payment_date = models.DateTimeField(null=True,
editable=False,
verbose_name=_("payment date"))
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=False, verbose_name=_("marketing permission"))
_codes = JSONField(blank=True, null=True, verbose_name=_("codes"))
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 ShuupSettings.get_setting("SHUUP_ENABLE_MULTIPLE_SHOPS"):
return "Order %s (%s, %s)" % (self.identifier, self.shop.name,
name)
else:
return "Order %s (%s)" % (self.identifier, name)
@property
def codes(self):
return list(self._codes or [])
@codes.setter
def codes(self, value):
codes = []
for code in value:
if not isinstance(code, six.text_type):
raise TypeError("Error! `codes` must be a list of strings.")
codes.append(code)
self._codes = codes
def cache_prices(self):
taxful_total = TaxfulPrice(0, self.currency)
taxless_total = TaxlessPrice(0, self.currency)
for line in self.lines.all().prefetch_related("taxes"):
taxful_total += line.taxful_price
taxless_total += line.taxless_price
self.taxful_total_price = taxful_total
self.taxless_total_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
if not self.id and self.customer:
# These fields are used for reporting and should not
# change after create even if empty at the moment of ordering.
self.account_manager = getattr(self.customer, "account_manager",
None)
self.tax_group = self.customer.tax_group
def _cache_contact_values_post_create(self):
if self.customer:
# These fields are used for reporting and should not
# change after create even if empty at the moment of ordering.
self.customer_groups.set(self.customer.groups.all())
def _cache_values(self):
self._cache_contact_values()
if not self.label:
self.label = settings.SHUUP_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)
if not self.modified_by:
self.modified_by = self.creator
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 save(self, *args, **kwargs):
if not self.creator_id:
if not settings.SHUUP_ALLOW_ANONYMOUS_ORDERS:
raise ValidationError(
"Error! Anonymous (userless) orders are not allowed "
"when `SHUUP_ALLOW_ANONYMOUS_ORDERS` is not enabled.")
self._cache_values()
first_save = not self.pk
old_status = self.status
if not first_save:
old_status = Order.objects.only("status").get(pk=self.pk).status
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()
self._cache_contact_values_post_create()
order_changed.send(type(self), order=self)
if self.status != old_status:
order_status_changed.send(type(self),
order=self,
old_status=old_status,
new_status=self.status)
def delete(self, using=None):
if not self.deleted:
self.deleted = True
self.add_log_entry("Success! Deleted (soft).",
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 was marked as paid."))
self.payment_status = PaymentStatus.FULLY_PAID
self.payment_date = local_now()
self.save()
def _set_partially_paid(self):
if self.payment_status != PaymentStatus.PARTIALLY_PAID:
self.add_log_entry(_("Order was marked as partially paid."))
self.payment_status = PaymentStatus.PARTIALLY_PAID
self.save()
def is_paid(self):
return self.payment_status == PaymentStatus.FULLY_PAID
def is_partially_paid(self):
return self.payment_status == PaymentStatus.PARTIALLY_PAID
def is_deferred(self):
return self.payment_status == PaymentStatus.DEFERRED
def is_not_paid(self):
return self.payment_status == PaymentStatus.NOT_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 get_total_unpaid_amount(self):
difference = self.taxful_total_price.amount - self.get_total_paid_amount(
)
return max(difference, Money(0, self.currency))
def can_create_payment(self):
zero = Money(0, self.currency)
return not (self.is_paid() or self.is_canceled()
) and self.get_total_unpaid_amount() > zero
def create_payment(self, amount, payment_identifier=None, description=""):
"""
Create a payment with a 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` and the order is not
a zero price order, 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
a 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: shuup.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 and self.taxful_total_price:
raise NoPaymentToCreateException(
"Error! 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
else:
self._set_partially_paid()
payment_created.send(sender=type(self), order=self, payment=payment)
return payment
def can_create_shipment(self):
return self.get_unshipped_products(
) and not self.is_canceled() and self.shipping_address
# TODO: Rethink either the usage of shipment parameter or renaming the method for 2.0
@atomic
def create_shipment(self,
product_quantities,
supplier=None,
shipment=None):
"""
Create a shipment for this order from `product_quantities`.
`product_quantities` is expected to be a dict, which maps 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.
Orders without a shipping address defined, will raise `NoShippingAddressException`.
:param product_quantities: a dict mapping Product instances to quantities to ship.
:type product_quantities: dict[shuup.shop.models.Product, decimal.Decimal]
:param supplier: Optional Supplier for this product. No validation is made.
:param shipment: Optional unsaved Shipment for ShipmentProduct's. If not given
Shipment is created based on supplier parameter.
:raises: NoProductsToShipException, NoShippingAddressException
:return: Saved, complete Shipment object.
:rtype: shuup.core.models.Shipment
"""
if not product_quantities or not any(
quantity > 0 for quantity in product_quantities.values()):
raise NoProductsToShipException(
"Error! No products to ship (`quantities` is empty or has no quantity over 0)."
)
if self.shipping_address is None:
raise NoShippingAddressException(
"Error! Shipping address is not defined for this order.")
assert supplier or shipment
if shipment:
assert shipment.order == self
else:
from ._shipments import Shipment
shipment = Shipment(order=self, supplier=supplier)
shipment.save()
if not supplier:
supplier = shipment.supplier
supplier.module.ship_products(shipment, product_quantities)
self.add_log_entry(
_("Success! Shipment #%d was created.") % shipment.id)
self.update_shipping_status()
shipment_created.send(sender=type(self), order=self, shipment=shipment)
shipment_created_and_processed.send(sender=type(self),
order=self,
shipment=shipment)
return shipment
def can_create_refund(self, supplier=None):
unrefunded_amount = self.get_total_unrefunded_amount(supplier)
unrefunded_quantity = self.get_total_unrefunded_quantity(supplier)
return ((unrefunded_amount.value > 0 or unrefunded_quantity > 0)
and not self.is_canceled()
and (self.payment_status
not in (PaymentStatus.NOT_PAID, PaymentStatus.CANCELED)))
@atomic
def create_refund(self, refund_data, created_by=None, supplier=None):
"""
Create a refund if passed a list of refund line data.
Refund line data is simply a list of dictionaries where
each dictionary contains data for a particular refund line.
Additionally, if the parent line is of `enum` type
`OrderLineType.PRODUCT` and the `restock_products` boolean
flag is set to `True`, the products will be restocked with the
exact amount set in the order supplier's `quantity` field.
:param refund_data: List of dicts containing refund data.
:type refund_data: [dict]
:param created_by: Refund creator's user instance, used for
adjusting supplier stock.
:type created_by: django.contrib.auth.User|None
"""
tax_module = taxing.get_tax_module()
refund_lines = tax_module.create_refund_lines(self, supplier,
created_by, refund_data)
self.cache_prices()
self.save()
self.update_shipping_status()
self.update_payment_status()
refund_created.send(sender=type(self),
order=self,
refund_lines=refund_lines)
def create_full_refund(self, restock_products=False, created_by=None):
"""
Create a full refund for entire order content, with the option of
restocking stocked products.
:param restock_products: Boolean indicating whether to also restock the products.
:param created_by: Refund creator's user instance, used for
adjusting supplier stock.
:type restock_products: bool|False
"""
if self.has_refunds():
raise NoRefundToCreateException
self.cache_prices()
line_data = [{
"line": line,
"quantity": line.quantity,
"amount": line.taxful_price.amount,
"restock_products": restock_products,
} for line in self.lines.filter(quantity__gt=0)
if line.type != OrderLineType.REFUND]
self.create_refund(line_data, created_by)
def get_total_refunded_amount(self, supplier=None):
refunds = self.lines.refunds()
if supplier:
refunds = refunds.filter(
Q(parent_line__supplier=supplier) | Q(supplier=supplier))
total = sum([line.taxful_price.amount.value for line in refunds])
return Money(-total, self.currency)
def get_total_unrefunded_amount(self, supplier=None):
if supplier:
total_refund_amount = sum([
line.max_refundable_amount.value for line in self.lines.filter(
supplier=supplier).exclude(type=OrderLineType.REFUND)
])
arbitrary_refunds = abs(
sum([
refund_line.taxful_price.value for refund_line in
self.lines.filter(supplier=supplier,
parent_line__isnull=True,
type=OrderLineType.REFUND)
]))
return (Money(max(total_refund_amount -
arbitrary_refunds, 0), self.currency)
if total_refund_amount else Money(0, self.currency))
return max(self.taxful_total_price.amount, Money(0, self.currency))
def get_total_unrefunded_quantity(self, supplier=None):
queryset = self.lines.all()
if supplier:
queryset = queryset.filter(supplier=supplier)
return sum([line.max_refundable_quantity for line in queryset])
def get_total_tax_amount(self):
return sum((line.tax_amount for line in self.lines.all()),
Money(0, self.currency))
def has_refunds(self):
return self.lines.refunds().exists()
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: shuup.shop.models.Shipment
"""
from ._products import ShippingMode
suppliers_to_product_quantities = defaultdict(
lambda: defaultdict(lambda: 0))
lines = self.lines.filter(
type=OrderLineType.PRODUCT,
product__shipping_mode=ShippingMode.SHIPPED).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(
"Error! Could not find any products to ship.")
if supplier is None:
if len(suppliers_to_product_quantities) > 1: # pragma: no cover
raise ValueError(
"Error! `create_shipment_of_all_products` can be used only when there is a single 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(quantities, supplier=supplier)
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_price
return taxing.TaxSummary.from_line_taxes(all_line_taxes, untaxed)
def get_product_ids_and_quantities(self, supplier=None):
lines = self.lines.filter(type=OrderLineType.PRODUCT)
if supplier:
supplier_id = supplier if isinstance(
supplier, six.integer_types) else supplier.pk
lines = lines.filter(supplier_id=supplier_id)
quantities = defaultdict(lambda: 0)
for product_id, quantity in lines.values_list("product_id",
"quantity"):
quantities[product_id] += quantity
return dict(quantities)
def has_products(self):
return self.lines.products().exists()
def has_products_requiring_shipment(self, supplier=None):
from ._products import ShippingMode
lines = self.lines.products().filter(
product__shipping_mode=ShippingMode.SHIPPED)
if supplier:
supplier_id = supplier if isinstance(
supplier, six.integer_types) else supplier.pk
lines = lines.filter(supplier_id=supplier_id)
return lines.exists()
def is_complete(self):
return self.status.role == OrderStatusRole.COMPLETE
def can_set_complete(self):
return not (self.is_complete() or self.is_canceled()
or bool(self.get_unshipped_products()))
def is_fully_shipped(self):
return self.shipping_status == ShippingStatus.FULLY_SHIPPED
def is_partially_shipped(self):
return self.shipping_status == ShippingStatus.PARTIALLY_SHIPPED
def is_canceled(self):
return self.status.role == OrderStatusRole.CANCELED
def can_set_canceled(self):
canceled = self.status.role == OrderStatusRole.CANCELED
paid = self.is_paid()
shipped = self.shipping_status != ShippingStatus.NOT_SHIPPED
return not (canceled or paid or shipped)
def update_shipping_status(self):
status_before_update = self.shipping_status
if not self.get_unshipped_products():
self.shipping_status = ShippingStatus.FULLY_SHIPPED
elif self.shipments.all_except_deleted().count():
self.shipping_status = ShippingStatus.PARTIALLY_SHIPPED
else:
self.shipping_status = ShippingStatus.NOT_SHIPPED
if status_before_update != self.shipping_status:
self.add_log_entry(
_("New shipping status is set to: %(shipping_status)s." %
{"shipping_status": self.shipping_status}))
self.save(update_fields=("shipping_status", ))
def update_payment_status(self):
status_before_update = self.payment_status
if self.get_total_unpaid_amount().value == 0:
self.payment_status = PaymentStatus.FULLY_PAID
elif self.get_total_paid_amount().value > 0:
self.payment_status = PaymentStatus.PARTIALLY_PAID
elif self.payment_status != PaymentStatus.DEFERRED: # Do not make deferred here not paid
self.payment_status = PaymentStatus.NOT_PAID
if status_before_update != self.payment_status:
self.add_log_entry(
_("New payment status is set to: %(payment_status)s." %
{"payment_status": self.payment_status}))
self.save(update_fields=("payment_status", ))
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.SHUUP_ORDER_KNOWN_PAYMENT_DATA_KEYS),
(self.shipping_data,
settings.SHUUP_ORDER_KNOWN_SHIPPING_DATA_KEYS),
(self.extra_data, settings.SHUUP_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, supplier=None):
"""Return a dict of product IDs -> {ordered, unshipped, refunded, shipped, line_text, suppliers}"""
supplier_id = (supplier if isinstance(supplier, six.integer_types) else
supplier.pk) if supplier else None
products = defaultdict(lambda: defaultdict(lambda: Decimal(0)))
def _append_suppliers_info(product_id, supplier):
if not products[product_id]["suppliers"]:
products[product_id]["suppliers"] = [supplier]
elif supplier not in products[product_id]["suppliers"]:
products[product_id]["suppliers"].append(supplier)
# Quantity for all orders
# Note! This contains all product lines so we do not need to worry
# about suppliers after this.
lines = self.lines.filter(type=OrderLineType.PRODUCT)
if supplier_id:
lines = lines.filter(supplier_id=supplier_id)
lines_values = lines.values_list("product_id", "text", "quantity",
"supplier__name")
for product_id, line_text, quantity, supplier_name in lines_values:
products[product_id]["line_text"] = line_text
products[product_id]["ordered"] += quantity
_append_suppliers_info(product_id, supplier_name)
# Quantity to ship
for product_id, quantity in self._get_to_ship_quantities(supplier_id):
products[product_id]["unshipped"] += quantity
# Quantity shipped
for product_id, quantity in self._get_shipped_quantities(supplier_id):
products[product_id]["shipped"] += quantity
products[product_id]["unshipped"] -= quantity
# Quantity refunded
for product_id in self._get_refunded_product_ids(supplier_id):
refunds = self.lines.refunds().filter(
parent_line__product_id=product_id)
refunded_quantity = refunds.aggregate(
total=models.Sum("quantity"))["total"] or 0
products[product_id]["refunded"] = refunded_quantity
products[product_id]["unshipped"] = max(
products[product_id]["unshipped"] - refunded_quantity, 0)
return products
def _get_to_ship_quantities(self, supplier_id):
from ._products import ShippingMode
lines_to_ship = self.lines.filter(
type=OrderLineType.PRODUCT,
product__shipping_mode=ShippingMode.SHIPPED)
if supplier_id:
lines_to_ship = lines_to_ship.filter(supplier_id=supplier_id)
return lines_to_ship.values_list("product_id", "quantity")
def _get_shipped_quantities(self, supplier_id):
from ._shipments import ShipmentProduct, ShipmentStatus
shipment_prods = ShipmentProduct.objects.filter(
shipment__order=self).exclude(
shipment__status=ShipmentStatus.DELETED)
if supplier_id:
shipment_prods = shipment_prods.filter(
shipment__supplier_id=supplier_id)
return shipment_prods.values_list("product_id", "quantity")
def _get_refunded_product_ids(self, supplier_id):
refunded_prods = self.lines.refunds().filter(
type=OrderLineType.REFUND, parent_line__type=OrderLineType.PRODUCT)
if supplier_id:
refunded_prods = refunded_prods.filter(
parent_line__supplier_id=supplier_id)
return refunded_prods.distinct().values_list("parent_line__product_id",
flat=True)
def get_unshipped_products(self, supplier=None):
return dict((product, summary_datum)
for product, summary_datum in self.get_product_summary(
supplier=supplier).items()
if summary_datum["unshipped"])
def get_status_display(self):
return force_text(self.status)
def get_payment_method_display(self):
return force_text(self.payment_method_name)
def get_shipping_method_display(self):
return force_text(self.shipping_method_name)
def get_tracking_codes(self):
return [
shipment.tracking_code
for shipment in self.shipments.all_except_deleted()
if shipment.tracking_code
]
def get_sent_shipments(self):
return self.shipments.all_except_deleted().sent()
def can_edit(self):
return (settings.SHUUP_ALLOW_EDITING_ORDER and not self.has_refunds()
and not self.is_canceled() and not self.is_complete()
and self.shipping_status == ShippingStatus.NOT_SHIPPED
and self.payment_status == PaymentStatus.NOT_PAID)
def get_customer_name(self):
name_attrs = [
"customer", "billing_address", "orderer", "shipping_address"
]
for attr in name_attrs:
if getattr(self, "%s_id" % attr):
return getattr(self, attr).name
def get_available_shipping_methods(self):
"""
Get available shipping methods.
:rtype: list[ShippingMethod]
"""
from shuup.core.models import ShippingMethod
product_ids = self.lines.products().values_list("id", flat=True)
return [
m for m in ShippingMethod.objects.available(shop=self.shop,
products=product_ids)
if m.is_available_for(self)
]
def get_available_payment_methods(self):
"""
Get available payment methods.
:rtype: list[PaymentMethod]
"""
from shuup.core.models import PaymentMethod
product_ids = self.lines.products().values_list("id", flat=True)
return [
m for m in PaymentMethod.objects.available(shop=self.shop,
products=product_ids)
if m.is_available_for(self)
]
class ShopProduct(MoneyPropped, TranslatableModel):
shop = models.ForeignKey("Shop", related_name="shop_products", on_delete=models.CASCADE, verbose_name=_("shop"))
product = UnsavedForeignKey(
"Product", related_name="shop_products", on_delete=models.CASCADE, verbose_name=_("product"))
suppliers = models.ManyToManyField(
"Supplier", related_name="shop_products", blank=True, verbose_name=_("suppliers"), help_text=_(
"List your suppliers here. Suppliers can be found by searching for `Suppliers`."
)
)
visibility = EnumIntegerField(
ShopProductVisibility,
default=ShopProductVisibility.ALWAYS_VISIBLE,
db_index=True,
verbose_name=_("visibility"),
help_text=mark_safe_lazy(_(
"Choose how you want your product to be seen and found by the customers. "
"<p>Not visible: Product will not be shown in your store front nor found in search.</p>"
"<p>Searchable: Product will be shown in search, but not listed on any category page.</p>"
"<p>Listed: Product will be shown on category pages, but not shown in search results.</p>"
"<p>Always Visible: Product will be shown in your store front and found in search.</p>"
))
)
purchasable = models.BooleanField(default=True, db_index=True, verbose_name=_("purchasable"))
visibility_limit = EnumIntegerField(
ProductVisibility, db_index=True, default=ProductVisibility.VISIBLE_TO_ALL,
verbose_name=_('visibility limitations'), help_text=_(
"Select whether you want your product to have special limitations on its visibility in your store. "
"You can make products visible to all, visible to only logged-in users, or visible only to certain "
"customer groups."
)
)
visibility_groups = models.ManyToManyField(
"ContactGroup", related_name='visible_products', verbose_name=_('visible for groups'), blank=True, help_text=_(
u"Select the groups you want to make your product visible for. "
u"These groups are defined in Contacts Settings - Contact Groups."
)
)
backorder_maximum = QuantityField(
default=0, blank=True, null=True, verbose_name=_('backorder maximum'), help_text=_(
"The number of units that can be purchased after the product is already sold out (out of stock). "
"Set to blank for product to be purchasable without limits."
))
purchase_multiple = QuantityField(default=0, verbose_name=_('purchase multiple'), help_text=_(
"Set this to other than 0 if the product needs to be purchased in multiples. "
"For example, if the purchase multiple is set to 2, then customers are required to order the product "
"in multiples of 2. Not to be confused with the Minimum Purchase Quantity."
)
)
minimum_purchase_quantity = QuantityField(default=1, verbose_name=_('minimum purchase quantity'), help_text=_(
"Set a minimum number of products needed to be ordered for the purchase. "
"This is useful for setting bulk orders and B2B purchases."
)
)
limit_shipping_methods = models.BooleanField(
default=False, verbose_name=_("limit the shipping methods"), help_text=_(
"Enable this if you want to limit your product to use only the select shipping methods. "
"You can select the allowed shipping method(s) in the field below - all the rest "
"are disallowed."
)
)
limit_payment_methods = models.BooleanField(
default=False, verbose_name=_("limit the payment methods"), help_text=_(
"Enable this if you want to limit your product to use only the select payment methods. "
"You can select the allowed payment method(s) in the field below - all the rest "
"are disallowed."
)
)
shipping_methods = models.ManyToManyField(
"ShippingMethod", related_name='shipping_products', verbose_name=_('shipping methods'), blank=True, help_text=_(
"If you enabled the `Limit the payment methods` choice above, then here you can select the "
"individual shipping methods you want to ALLOW for this product. The ones not mentioned are "
"disabled. To change this, search for `Shipping Methods`."
)
)
payment_methods = models.ManyToManyField(
"PaymentMethod", related_name='payment_products', verbose_name=_('payment methods'), blank=True, help_text=_(
"If you enabled the `Limit the payment methods` choice above, then here you can select the "
"individuals payment methods you want to ALLOW for this product. The ones not mentioned are "
"disabled. To change this, search for `Payment Methods`."
)
)
primary_category = models.ForeignKey(
"Category", related_name='primary_shop_products', verbose_name=_('primary category'), blank=True, null=True,
on_delete=models.PROTECT, help_text=_(
"Choose the primary category for the product. "
"This will be the main category for classification in the system. "
"The product will be found under this category in your store. "
"To change this, search for `Categories`."
)
)
categories = models.ManyToManyField(
"Category", related_name='shop_products', verbose_name=_('categories'), blank=True, help_text=_(
"Add secondary categories for your product. "
"These are other categories that your product fits under and that it can be found by in your store."
)
)
shop_primary_image = models.ForeignKey(
"ProductMedia", null=True, blank=True,
related_name="primary_image_for_shop_products", on_delete=models.SET_NULL,
verbose_name=_("primary image"), help_text=_(
"Click this to set this image as the primary display image for the product."
)
)
# 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, help_text=_(
"This is the default individual base unit (or multi-pack) price of the product. "
"All discounts or coupons will be calculated based off of this price."
)
)
minimum_price = PriceProperty('minimum_price_value', 'shop.currency', 'shop.prices_include_tax')
minimum_price_value = MoneyValueField(verbose_name=_("minimum price"), null=True, blank=True, help_text=_(
"This is the default price that the product cannot go under in your store, "
"despite coupons or discounts being applied. "
"This is useful to make sure your product price stays above the cost."
)
)
available_until = models.DateTimeField(verbose_name=_("available until"), null=True, blank=True, help_text=_(
"After this date this product will be invisible in store front."
))
display_unit = models.ForeignKey(
DisplayUnit,
on_delete=models.CASCADE,
null=True, blank=True,
verbose_name=_("display unit"),
help_text=_("Unit for displaying quantities of this product.")
)
translations = TranslatedFields(
name=models.CharField(
blank=True, null=True, max_length=256, verbose_name=_('name'),
help_text=_("Enter a descriptive name for your product. This will be its title in your store front.")),
description=models.TextField(
blank=True, null=True, verbose_name=_('description'),
help_text=_(
"To make your product stands out, give it an awesome description. "
"This is what will help your shoppers learn about your products. "
"It will also help shoppers find them in the store and on the web."
)
),
short_description=models.CharField(
blank=True, null=True, max_length=150, verbose_name=_('short description'),
help_text=_(
"Enter a short description for your product. The short description will "
"be used to get the attention of your customer with a small, but "
"precise description of your product. It also helps with getting more "
"traffic via search engines."
)
),
status_text=models.CharField(
max_length=128, blank=True,
verbose_name=_('status text'),
help_text=_(
'This text will be shown alongside the product in the shop. '
'It is useful for informing customers of special stock numbers or preorders. '
'(Ex.: Available in a month)'
)
)
)
class Meta:
unique_together = (("shop", "product",),)
def save(self, *args, **kwargs):
self.clean()
super(ShopProduct, self).save(*args, **kwargs)
for supplier in self.suppliers.enabled():
supplier.module.update_stock(product_id=self.product.id)
def clean(self):
pre_clean.send(type(self), instance=self)
super(ShopProduct, self).clean()
if self.display_unit:
if self.display_unit.internal_unit != self.product.sales_unit:
raise ValidationError({'display_unit': _(
"Error! Invalid display unit: Internal unit of "
"the selected display unit does not match "
"with the sales unit of the product.")})
post_clean.send(type(self), instance=self)
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.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
@property
def searchable(self):
return self.visibility in (ShopProductVisibility.SEARCHABLE, ShopProductVisibility.ALWAYS_VISIBLE)
@property
def listed(self):
return self.visibility in (ShopProductVisibility.LISTED, ShopProductVisibility.ALWAYS_VISIBLE)
@property
def visible(self):
return not (self.visibility == ShopProductVisibility.NOT_VISIBLE)
@property
def public_primary_image(self):
primary_image = self.primary_image
return primary_image if primary_image and primary_image.public else None
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")
if self.available_until and self.available_until <= now():
yield ValidationError(
_("Error! This product is not available until the current date."),
code="product_not_available"
)
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"
)
# TODO: Remove from Shuup 2.0
for receiver, response in get_visibility_errors.send(ShopProduct, shop_product=self, customer=customer):
warnings.warn("Warning! Visibility errors through signals are deprecated.", DeprecationWarning)
for error in response:
yield error
def get_orderability_errors(self, supplier, quantity, customer, ignore_minimum=False):
"""
Yield ValidationErrors that would cause this product to not be orderable.
Shop product to be orderable it needs to be visible visible and purchasable.
:param supplier: Supplier to order this product from. May be None.
:type supplier: shuup.core.models.Supplier
:param quantity: Quantity to order.
:type quantity: int|Decimal
:param customer: Customer contact.
:type customer: shuup.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
for error in self.get_purchasability_errors(supplier, customer, quantity, ignore_minimum):
yield error
def get_purchasability_errors(self, supplier, customer, quantity, ignore_minimum=False):
"""
Yield ValidationErrors that would cause this product to not be purchasable.
Shop product to be purchasable it has to have purchasable attribute set on
and pass all quantity and supplier checks.
:param supplier: Supplier to order this product from. May be None.
:type supplier: shuup.core.models.Supplier
:param quantity: Quantity to order.
:type quantity: int|Decimal
:param customer: Customer contact.
:type customer: shuup.core.models.Contact
:param ignore_minimum: Ignore any limitations caused by quantity minimums.
:type ignore_minimum: bool
:return: Iterable[ValidationError]
"""
if not self.purchasable:
yield ValidationError(_("The product is not purchasable."), code="not_purchasable")
for error in self.get_quantity_errors(quantity, ignore_minimum):
yield error
for error in self.get_supplier_errors(supplier, customer, quantity, ignore_minimum):
yield error
# TODO: Remove from Shuup 2.0
for receiver, response in get_orderability_errors.send(
ShopProduct, shop_product=self, customer=customer, supplier=supplier, quantity=quantity
):
warnings.warn("Warning! Orderability errors through signals are deprecated.", DeprecationWarning)
for error in response:
yield error
def get_quantity_errors(self, quantity, ignore_minimum):
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"
)
purchase_multiple = self.purchase_multiple
if quantity > 0 and purchase_multiple > 0 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)
render_qty = self.unit.render_quantity
if larger_p == smaller_p:
message = _(
"The product can only be ordered in multiples of "
"{package_size}, for example {amount}.").format(
package_size=render_qty(purchase_multiple),
amount=render_qty(smaller_p))
else:
message = _(
"The product can only be ordered in multiples of "
"{package_size}, for example {smaller_amount} or "
"{larger_amount}.").format(
package_size=render_qty(purchase_multiple),
smaller_amount=render_qty(smaller_p),
larger_amount=render_qty(larger_p))
yield ValidationError(message, code="invalid_purchase_multiple")
def get_supplier_errors(self, supplier, customer, quantity, ignore_minimum):
enabled_supplier = self.suppliers.enabled(shop=self.shop)
if supplier is None and not enabled_supplier.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 supplier and not enabled_supplier.filter(pk=supplier.pk).exists():
yield ValidationError(
_("The product is not supplied by %s.") % supplier,
code="invalid_supplier"
)
errors = []
if self.product.mode == ProductMode.SIMPLE_VARIATION_PARENT:
errors = self.get_orderability_errors_for_simple_variation_parent(supplier, customer)
elif self.product.mode == ProductMode.VARIABLE_VARIATION_PARENT:
errors = self.get_orderability_errors_for_variable_variation_parent(supplier, customer)
elif self.product.is_package_parent():
errors = self.get_orderability_errors_for_package_parent(supplier, customer, quantity, ignore_minimum)
elif supplier: # Test supplier orderability only for variation children and normal products
errors = supplier.get_orderability_errors(self, quantity, customer=customer)
for error in errors:
yield error
def get_orderability_errors_for_simple_variation_parent(self, supplier, customer):
sellable = False
for child_product in self.product.variation_children.visible(shop=self.shop, customer=customer):
try:
child_shop_product = child_product.get_shop_instance(self.shop)
except ShopProduct.DoesNotExist:
continue
if child_shop_product.is_orderable(
supplier=supplier,
customer=customer,
quantity=child_shop_product.minimum_purchase_quantity,
allow_cache=False
):
sellable = True
break
if not sellable:
yield ValidationError(_("Product has no sellable children."), code="no_sellable_children")
def get_orderability_errors_for_variable_variation_parent(self, supplier, customer):
from shuup.core.models import ProductVariationResult
sellable = False
for combo in self.product.get_all_available_combinations():
res = ProductVariationResult.resolve(self.product, combo["variable_to_value"])
if not res:
continue
try:
child_shop_product = res.get_shop_instance(self.shop)
except ShopProduct.DoesNotExist:
continue
if child_shop_product.is_orderable(
supplier=supplier,
customer=customer,
quantity=child_shop_product.minimum_purchase_quantity,
allow_cache=False
):
sellable = True
break
if not sellable:
yield ValidationError(_("Product has no sellable children."), code="no_sellable_children")
def get_orderability_errors_for_package_parent(self, supplier, customer, quantity, ignore_minimum):
for child_product, child_quantity in six.iteritems(self.product.get_package_child_to_quantity_map()):
try:
child_shop_product = child_product.get_shop_instance(shop=self.shop, allow_cache=False)
except ShopProduct.DoesNotExist:
yield ValidationError(
"Error! %s is not available in %s." % (child_product, self.shop), code="invalid_shop")
else:
for error in child_shop_product.get_orderability_errors(
supplier=supplier,
quantity=(quantity * child_quantity),
customer=customer,
ignore_minimum=ignore_minimum
):
message = getattr(error, "message", "")
code = getattr(error, "code", None)
yield ValidationError("Error! %s: %s" % (child_product, message), code=code)
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, allow_cache=True):
"""
Product to be orderable it needs to be visible and purchasable.
"""
key, val = context_cache.get_cached_value(
identifier="is_orderable", item=self, context={"customer": customer},
supplier=supplier, stock_managed=bool(supplier and supplier.stock_managed),
quantity=quantity, allow_cache=allow_cache)
if customer and val is not None:
return val
if not supplier:
supplier = self.get_supplier(customer, quantity)
for message in self.get_orderability_errors(supplier=supplier, quantity=quantity, customer=customer):
if customer:
context_cache.set_cached_value(key, False)
return False
if customer:
context_cache.set_cached_value(key, True)
return True
def is_visible(self, customer):
"""
Visible products are shown in store front based on customer
or customer group limitations.
"""
for message in self.get_visibility_errors(customer=customer):
return False
return True
def is_purchasable(self, supplier, customer, quantity):
"""
Whether product can be purchased.
"""
for message in self.get_purchasability_errors(supplier, customer, quantity):
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 }}">
"""
step = self.purchase_multiple or self._sales_unit.quantity_step
return self._sales_unit.round(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._sales_unit.round(self.minimum_purchase_quantity)
@property
def display_quantity_step(self):
"""
Quantity step of this shop product in the display unit.
Note: This can never be smaller than the display precision.
"""
return max(
self.unit.to_display(self.quantity_step),
self.unit.display_precision)
@property
def display_quantity_minimum(self):
"""
Quantity minimum of this shop product in the display unit.
Note: This can never be smaller than the display precision.
"""
return max(
self.unit.to_display(self.minimum_purchase_quantity),
self.unit.display_precision)
@property
def unit(self):
"""
Unit of this product.
:rtype: shuup.core.models.UnitInterface
"""
return UnitInterface(self._sales_unit, self.display_unit)
@property
def _sales_unit(self):
return self.product.sales_unit or PiecesSalesUnit()
@property
def images(self):
return self.product.media.filter(shops=self.shop, kind=ProductMediaKind.IMAGE).order_by("ordering")
@property
def public_images(self):
return self.images.filter(public=True)
def get_supplier(self, customer=None, quantity=None, shipping_address=None):
supplier_strategy = cached_load("SHUUP_SHOP_PRODUCT_SUPPLIERS_STRATEGY")
kwargs = {
"shop_product": self,
"customer": customer,
"quantity": quantity,
"shipping_address": shipping_address
}
return supplier_strategy().get_supplier(**kwargs)
def __str__(self):
return self.get_name()
def get_name(self):
return self._safe_get_string("name")
def get_description(self):
return self._safe_get_string("description")
def get_short_description(self):
return self._safe_get_string("short_description")
def _safe_get_string(self, key):
return (
self.safe_translation_getter(key, any_language=True)
or self.product.safe_translation_getter(key, any_language=True)
)
class ShopProduct(MoneyPropped, models.Model):
shop = models.ForeignKey("Shop",
related_name="shop_products",
on_delete=models.CASCADE,
verbose_name=_("shop"))
product = UnsavedForeignKey("Product",
related_name="shop_products",
on_delete=models.CASCADE,
verbose_name=_("product"))
suppliers = models.ManyToManyField("Supplier",
related_name="shop_products",
blank=True,
verbose_name=_("suppliers"))
visible = models.BooleanField(default=True,
db_index=True,
verbose_name=_("visible"))
listed = models.BooleanField(default=True,
db_index=True,
verbose_name=_("listed"))
purchasable = models.BooleanField(default=True,
db_index=True,
verbose_name=_("purchasable"))
searchable = models.BooleanField(default=True,
db_index=True,
verbose_name=_("searchable"))
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, verbose_name=_("limited for shipping methods"))
limit_payment_methods = models.BooleanField(
default=False, verbose_name=_("limited for payment methods"))
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,
verbose_name=_("primary image"))
# 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)
minimum_price = PriceProperty('minimum_price_value', 'shop.currency',
'shop.prices_include_tax')
minimum_price_value = MoneyValueField(verbose_name=_("minimum price"),
null=True,
blank=True)
class Meta:
unique_together = ((
"shop",
"product",
), )
def save(self, *args, **kwargs):
super(ShopProduct, self).save(*args, **kwargs)
for supplier in self.suppliers.all():
supplier.module.update_stock(product_id=self.product.id)
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: shuup.core.models.Supplier
:param quantity: Quantity to order.
:type quantity: int|Decimal
:param customer: Customer contact.
:type customer: shuup.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):
if not supplier:
supplier = self.suppliers.first() # TODO: Allow multiple suppliers
for message in self.get_orderability_errors(supplier=supplier,
quantity=quantity,
customer=customer):
return False
return True
def is_visible(self, customer):
for message in self.get_visibility_errors(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 Order(MoneyPropped, models.Model):
# Identification
shop = UnsavedForeignKey("Shop", on_delete=models.PROTECT, verbose_name=_('shop'))
created_on = models.DateTimeField(auto_now_add=True, editable=False, verbose_name=_('created on'))
modified_on = models.DateTimeField(auto_now_add=True, editable=False, verbose_name=_('modified on'))
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 = models.ForeignKey(
"ImmutableAddress", related_name="billing_orders",
blank=True, null=True,
on_delete=models.PROTECT,
verbose_name=_('billing address'))
shipping_address = models.ForeignKey(
"ImmutableAddress", 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=64, 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'))
modified_by = UnsavedForeignKey(
settings.AUTH_USER_MODEL, related_name='orders_modified', blank=True, null=True,
on_delete=models.PROTECT,
verbose_name=_('modifier user'))
deleted = models.BooleanField(db_index=True, default=False, verbose_name=_('deleted'))
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=100, blank=True, default="",
verbose_name=_('payment method name'))
payment_data = JSONField(blank=True, null=True, verbose_name=_('payment data'))
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=100, blank=True, default="",
verbose_name=_('shipping method name'))
shipping_data = JSONField(blank=True, null=True, verbose_name=_('shipping data'))
extra_data = JSONField(blank=True, null=True, verbose_name=_('extra data'))
# 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(verbose_name=_('currency'))
prices_include_tax = models.BooleanField(verbose_name=_('prices include tax'))
display_currency = CurrencyField(blank=True, verbose_name=_('display currency'))
display_currency_rate = models.DecimalField(
max_digits=36, decimal_places=9, default=1, verbose_name=_('display currency rate')
)
# 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'))
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'))
_codes = JSONField(blank=True, null=True, verbose_name=_('codes'))
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.SHUUP_ENABLE_MULTIPLE_SHOPS:
return "Order %s (%s, %s)" % (self.identifier, self.shop.name, name)
else:
return "Order %s (%s)" % (self.identifier, name)
@property
def codes(self):
return list(self._codes or [])
@codes.setter
def codes(self, value):
codes = []
for code in value:
if not isinstance(code, six.text_type):
raise TypeError('codes must be a list of strings')
codes.append(code)
self._codes = codes
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_price
taxless_total += line.taxless_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.SHUUP_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)
if not self.modified_by:
self.modified_by = self.creator
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 save(self, *args, **kwargs):
if not self.creator_id:
if not settings.SHUUP_ALLOW_ANONYMOUS_ORDERS:
raise ValidationError(
"Anonymous (userless) orders are not allowed "
"when SHUUP_ALLOW_ANONYMOUS_ORDERS is not enabled.")
self._cache_values()
first_save = (not self.pk)
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()
for line in self.lines.exclude(product_id=None):
line.supplier.module.update_stock(line.product_id)
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 _set_partially_paid(self):
if self.payment_status != PaymentStatus.PARTIALLY_PAID:
self.add_log_entry(_('Order marked as partially paid.'))
self.payment_status = PaymentStatus.PARTIALLY_PAID
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 get_total_unpaid_amount(self):
difference = self.taxful_total_price.amount - self.get_total_paid_amount()
return max(difference, Money(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: shuup.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
else:
self._set_partially_paid()
return payment
@atomic
def create_shipment(self, product_quantities, supplier=None, shipment=None):
"""
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 product_quantities: a dict mapping Product instances to quantities to ship
:type product_quantities: dict[shuup.shop.models.Product, decimal.Decimal]
:param supplier: Optional Supplier for this product. No validation is made
as to whether the given supplier supplies the products.
:param shipment: Optional unsaved Shipment for ShipmentProduct's. If not given
Shipment is created based on supplier parameter.
:raises: NoProductsToShipException
:return: Saved, complete Shipment object
:rtype: shuup.core.models.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).")
assert (supplier or shipment)
if shipment:
assert shipment.order == self
from ._shipments import ShipmentProduct
if not shipment:
from ._shipments import Shipment
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.update_shipping_status()
shipment_created.send(sender=type(self), order=self, shipment=shipment)
return shipment
def create_refund(self, refund_data, created_by=None):
"""
Create a refund if passed a list of refund line data.
Refund line data is simply a list of dictionaries where
each dictionary contains data for a particular refund line.
If refund line data includes a parent line, the refund is
associated with that line and cannot exceed the line amount.
Additionally, if the parent line is of enum type
`OrderLineType.PRODUCT` and the `restock_products` boolean
flag is set to `True`, the products will be restocked with the
order's supplier the exact amount of the value of the `quantity`
field.
:param refund_data: List of dicts containing refund data.
:type refund_data: [dict]
:param created_by: Refund creator's user instance, used for
adjusting supplier stock.
:type created_by: django.contrib.auth.User|None
"""
index = self.lines.all().aggregate(models.Max("ordering"))["ordering__max"]
zero = Money(0, self.currency)
refund_lines = []
for refund in refund_data:
index += 1
amount = refund.get("amount", zero)
quantity = refund.get("quantity", 0)
parent_line = refund.get("line")
restock_products = refund.get("restock_products")
# TODO: Also raise this if the sum amount of refunds exceeds total,
# order amount, and do so before creating any order lines
self.cache_prices()
if amount > self.taxful_total_price.amount:
raise RefundExceedsAmountException
unit_price = parent_line.base_unit_price.amount if parent_line else zero
total_price = unit_price * quantity + amount
refund_line = OrderLine.objects.create(
text=_("Refund for %s" % parent_line.text) if parent_line else _("Manual refund"),
order=self,
type=OrderLineType.REFUND,
parent_line=parent_line,
ordering=index,
base_unit_price_value=-total_price,
quantity=1
)
refund_lines.append(refund_line)
if parent_line and parent_line.type == OrderLineType.PRODUCT:
product = parent_line.product
else:
product = None
if restock_products and quantity and product and (product.stock_behavior == StockBehavior.STOCKED):
parent_line.supplier.adjust_stock(product.id, quantity, created_by=created_by)
self.cache_prices()
self.save()
refund_created.send(sender=type(self), order=self, refund_lines=refund_lines)
def create_full_refund(self, restock_products=False):
"""
Create a full for entire order contents, with the option of
restocking stocked products.
:param restock_products: Boolean indicating whether to restock products
:type restock_products: bool|False
"""
if self.has_refunds():
raise NoRefundToCreateException
self.cache_prices()
amount = self.taxful_total_price.amount
self.create_refund([{"amount": amount}])
if restock_products:
for product_line in self.lines.filter(
type=OrderLineType.PRODUCT, product__stock_behavior=StockBehavior.STOCKED
):
product_line.supplier.adjust_stock(product_line.product.id, product_line.quantity)
def get_total_refunded_amount(self):
total = sum(line.taxful_price.amount.value for line in self.lines.refunds())
return Money(-total, self.currency)
def get_total_unrefunded_amount(self):
return max(self.taxful_total_price.amount, Money(0, self.currency))
def has_refunds(self):
return self.lines.refunds().exists()
def can_create_refund(self):
return (self.taxful_total_price.amount.value > 0)
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: shuup.shop.models.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(quantities, supplier=supplier)
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_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 is_canceled(self):
return (self.status.role == OrderStatusRole.CANCELED)
def can_set_canceled(self):
canceled = (self.status.role == OrderStatusRole.CANCELED)
paid = self.is_paid()
shipped = (self.shipping_status != ShippingStatus.NOT_SHIPPED)
return not (canceled or paid or shipped)
def update_shipping_status(self):
if self.shipping_status == ShippingStatus.FULLY_SHIPPED:
return
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",))
elif self.shipments.count():
self.shipping_status = ShippingStatus.PARTIALLY_SHIPPED
self.save(update_fields=("shipping_status",))
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.SHUUP_ORDER_KNOWN_PAYMENT_DATA_KEYS),
(self.shipping_data, settings.SHUUP_ORDER_KNOWN_SHIPPING_DATA_KEYS),
(self.extra_data, settings.SHUUP_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)
def get_tracking_codes(self):
return [shipment.tracking_code for shipment in self.shipments.all() if shipment.tracking_code]
def can_edit(self):
return (
not self.has_refunds() and
not self.is_canceled() and
not self.is_complete() and
self.shipping_status == ShippingStatus.NOT_SHIPPED and
self.payment_status == PaymentStatus.NOT_PAID
)
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: shuup.utils.money.Money
"""
zero = Money(0, self.order.currency)
return sum((x.amount for x in self.taxes.all()), zero)
@property
def max_refundable_amount(self):
"""
:rtype: shuup.utils.money.Money
"""
refunds = self.order.lines.refunds().filter(parent_line=self)
refund_total_value = sum(refund.taxful_price.amount.value
for refund in refunds)
return (self.taxful_price.amount +
Money(refund_total_value, self.order.currency))
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 OrderLine(AbstractOrderLine):
order = UnsavedForeignKey("Order", related_name='lines', on_delete=models.PROTECT, verbose_name=_('order'))
