def test_analog():
PseudoPaymentProcessorLogEntry = define_log_model(PseudoPaymentProcessor)
assert PseudoPaymentProcessorLogEntry.__module__ == PseudoPaymentProcessor.__module__
related_field_name = "related"
# Behavior changs in Django 1.9
if VERSION >= (1, 9):
related_field_name = "rel"
relation_manager = getattr(PseudoPaymentProcessorLogEntry._meta.get_field("target"), related_field_name)
assert relation_manager.to is PseudoPaymentProcessor
relation_manager = getattr(PseudoPaymentProcessor.log_entries, related_field_name)
assert relation_manager.model is PseudoPaymentProcessor
assert relation_manager.related_model is PseudoPaymentProcessorLogEntry
assert issubclass(PseudoPaymentProcessorLogEntry, BaseLogEntry)
assert isinstance(PseudoPaymentProcessorLogEntry(), BaseLogEntry)
Shipment, related_name='products', on_delete=models.PROTECT, verbose_name=_("shipment")
)
product = models.ForeignKey(
"Product", related_name='shipments', on_delete=models.CASCADE, verbose_name=_("product")
)
quantity = QuantityField(verbose_name=_("quantity"))
# volume is m^3, not mm^3, because mm^3 are tiny. like ants.
unit_volume = MeasurementField(unit="m3", verbose_name=_("unit volume"))
unit_weight = MeasurementField(unit="g", verbose_name=_("unit weight"))
class Meta:
verbose_name = _('sent product')
verbose_name_plural = _('sent products')
def __str__(self): # pragma: no cover
return "%(quantity)s of '%(product)s' in Shipment #%(shipment_pk)s" % {
'product': self.product,
'quantity': self.quantity,
'shipment_pk': self.shipment_id,
}
def cache_values(self):
prod = self.product
self.unit_volume = (prod.width * prod.height * prod.depth) / CUBIC_MM_TO_CUBIC_METERS_DIVISOR
self.unit_weight = prod.gross_weight
ShipmentLogEntry = define_log_model(Shipment)
ShipmentProductLogEntry = define_log_model(ShipmentProduct)
class Meta:
verbose_name = _("custom payment processor")
verbose_name_plural = _("custom payment processors")
def get_service_choices(self):
return [
ServiceChoice('manual', _("Manually processed payment")),
ServiceChoice('cash', _("Cash payment"))
]
def _create_service(self, choice_identifier, **kwargs):
service = super(CustomPaymentProcessor,
self)._create_service(choice_identifier, **kwargs)
if choice_identifier == 'cash':
service.behavior_components.add(
StaffOnlyBehaviorComponent.objects.create())
return service
def process_payment_return_request(self, service, order, request):
if service == 'cash':
if not order.is_paid():
order.create_payment(order.taxful_total_price,
payment_identifier="Cash-%s" %
now().isoformat(),
description="Cash Payment")
PaymentMethodLogEntry = define_log_model(PaymentMethod)
PaymentProcessorLogEntry = define_log_model(PaymentProcessor)
from django.utils.translation import ugettext_lazy as _
from wshop.core.fields import QuantityField
from wshop.utils.analog import define_log_model
class SuppliedProduct(models.Model):
supplier = models.ForeignKey("Supplier",
on_delete=models.CASCADE,
verbose_name=_("supplier"))
product = models.ForeignKey("Product",
on_delete=models.CASCADE,
verbose_name=_("product"))
sku = models.CharField(db_index=True,
max_length=128,
verbose_name=_('SKU'))
alert_limit = models.IntegerField(default=0, verbose_name=_('alert limit'))
physical_count = QuantityField(editable=False,
verbose_name=_('physical stock count'))
logical_count = QuantityField(editable=False,
verbose_name=_('logical stock count'))
class Meta:
unique_together = ((
"supplier",
"product",
), )
SuppliedProductLogEntry = define_log_model(SuppliedProduct)
default=SavedAddressRole.SHIPPING)
status = EnumIntegerField(SavedAddressStatus,
default=SavedAddressStatus.ENABLED,
verbose_name=_('status'))
title = models.CharField(max_length=255,
blank=True,
verbose_name=_('title'))
objects = SavedAddressManager()
class Meta:
verbose_name = _('saved address')
verbose_name_plural = _('saved addresses')
ordering = ("owner_id", "role", "title")
def __str__(self):
return u"%s" % self.get_title()
def get_title(self):
"""
Returns the display title for this `SavedAddress` instance. Defaults
to a short representation of the address.
This method should be used instead of accessing the `title` field
directly when displaying `SavedAddress` objects.
"""
return self.title.strip() if self.title else six.text_type(
self.address)
SavedAddressLogEntry = define_log_model(SavedAddress)
return get_thumbnailer(self.file)
def get_thumbnail(self, **kwargs):
"""
Get thumbnail for image
This will return `None` if there is no file or kind is not `ProductMediaKind.IMAGE`
:rtype: easy_thumbnails.files.ThumbnailFile|None
"""
kwargs.setdefault("size", (64, 64))
kwargs.setdefault("crop", True) # sane defaults
kwargs.setdefault("upscale", True) # sane defaults
if kwargs["size"] is (0, 0):
return None
thumbnailer = self.easy_thumbnails_thumbnailer
if not thumbnailer:
return None
try:
return thumbnailer.get_thumbnail(thumbnail_options=kwargs)
except InvalidImageFormatError:
return None
ProductMediaLogEntry = define_log_model(ProductMedia)
"""
:param shop: Shop to check for suppliability
:type shop: wshop.core.models.Shop
:param customer: Customer contact to check for suppliability
:type customer: wshop.core.models.Contact
:rtype: list[int]
"""
return [
shop_product.pk
for shop_product in self.shop_products.filter(shop=shop)
if shop_product.is_orderable(
self, customer, shop_product.minimum_purchase_quantity)
]
def adjust_stock(self, product_id, delta, created_by=None, type=None):
from wshop.core.suppliers.base import StockAdjustmentType
adjustment_type = type or StockAdjustmentType.INVENTORY
return self.module.adjust_stock(product_id,
delta,
created_by=created_by,
type=adjustment_type)
def update_stock(self, product_id):
return self.module.update_stock(product_id)
def update_stocks(self, product_ids):
return self.module.update_stocks(product_ids)
SupplierLogEntry = define_log_model(Supplier)
"Not implemented: Use `soft_delete()` for categories.")
@atomic
def soft_delete(self, user=None):
if not self.status == CategoryStatus.DELETED:
for shop_product in self.primary_shop_products.all():
shop_product.categories.remove(self)
shop_product.primary_category = None
shop_product.save()
for shop_product in self.shop_products.all():
shop_product.categories.remove(self)
shop_product.primary_category = None
shop_product.save()
for child in self.children.all():
child.parent = None
child.save()
self.status = CategoryStatus.DELETED
self.add_log_entry("Deleted.",
kind=LogEntryKind.DELETION,
user=user)
self.save()
category_deleted.send(sender=type(self), category=self)
def save(self, *args, **kwargs):
rv = super(Category, self).save(*args, **kwargs)
generate_multilanguage_slugs(self, self._get_slug_name)
return rv
CategoryLogEntry = define_log_model(Category)
Note: `Carrier` objects should never be created on their own but
rather through a concrete subclass.
"""
service_model = ShippingMethod
def delete(self, *args, **kwargs):
ShippingMethod.objects.filter(carrier=self).update(
**{"enabled": False})
super(Carrier, self).delete(*args, **kwargs)
def _create_service(self, choice_identifier, **kwargs):
return ShippingMethod.objects.create(
carrier=self, choice_identifier=choice_identifier, **kwargs)
class CustomCarrier(Carrier):
"""
Carrier without any integration or special processing.
"""
class Meta:
verbose_name = _("custom carrier")
verbose_name_plural = _("custom carriers")
def get_service_choices(self):
return [ServiceChoice('manual', _("Manually processed shipment"))]
ShippingMethodLogEntry = define_log_model(ShippingMethod)
CarrierLogEntry = define_log_model(Carrier)
identifier = InternalIdentifierField(unique=True)
shops = models.ManyToManyField("wshop.Shop",
blank=True,
verbose_name=_("shops"))
name = models.CharField(
max_length=128,
verbose_name=_('name'),
help_text=_(
"Enter the manufacturer’s name. "
"Products can be filtered by the manufacturer and can be useful for inventory and stock management."
))
url = models.CharField(
null=True,
blank=True,
max_length=128,
verbose_name=_('URL'),
help_text=_(
"Enter the URL of the product manufacturer if you would like customers to be able to visit the manufacturer's "
"website."))
class Meta:
verbose_name = _('manufacturer')
verbose_name_plural = _('manufacturers')
def __str__(self): # pragma: no cover
return u'%s' % (self.name)
ManufacturerLogEntry = define_log_model(Manufacturer)
objects = ShopManager()
class Meta:
verbose_name = _('shop')
verbose_name_plural = _('shops')
def __str__(self):
return self.safe_translation_getter("name",
default="Shop %d" % self.pk)
def create_price(self, value):
"""
Create a price with given value and settings of this shop.
Takes the ``prices_include_tax`` and ``currency`` settings of
this Shop into account.
:type value: decimal.Decimal|int|str
:rtype: wshop.core.pricing.Price
"""
if self.prices_include_tax:
return TaxfulPrice(value, self.currency)
else:
return TaxlessPrice(value, self.currency)
def _are_changes_protected(self):
return Order.objects.filter(shop=self).exists()
ShopLogEntry = define_log_model(Shop)
foreign_currency = CurrencyField(default=None,
blank=True,
null=True,
verbose_name=_('foreign amount currency'))
description = models.CharField(max_length=256,
blank=True,
verbose_name=_('description'))
class Meta:
abstract = True
# TODO (2.0): Rename this to OrderPayment
class Payment(AbstractPayment):
order = models.ForeignKey("Order",
related_name='payments',
on_delete=models.PROTECT,
verbose_name=_('order'))
class Meta:
verbose_name = _('payment')
verbose_name_plural = _('payments')
@property
def currency(self):
return self.order.currency
PaymentLogEntry = define_log_model(Payment)
max_length=100,
verbose_name=_('name'),
help_text=_(
"The customer tax group name. "
"Customer tax groups can be used to control how taxes are applied to a set of customers. "
)), )
enabled = models.BooleanField(default=True, verbose_name=_('enabled'))
class Meta:
verbose_name = _('customer tax group')
verbose_name_plural = _('customer tax groups')
@classmethod
def get_default_person_group(cls):
obj, c = CustomerTaxGroup.objects.get_or_create(
identifier="default_person_customers",
defaults={"name": _("Retail Customers")})
return obj
@classmethod
def get_default_company_group(cls):
obj, c = CustomerTaxGroup.objects.get_or_create(
identifier="default_company_customers",
defaults={"name": _("Company Customers")})
return obj
TaxLogEntry = define_log_model(Tax)
TaxClassLogEntry = define_log_model(TaxClass)
CustomerTaxGroupLogEntry = define_log_model(CustomerTaxGroup)
applied_attr.set_current_language(language)
if not attr.is_translated and attr.is_null_value(value):
# Trying to set a null value for an untranslated attribute,
# so we can just get rid of the applied object altogether.
# TODO: Do the same sort of cleanup for translated attributes.
if applied_attr.pk:
applied_attr.delete()
return
# Set the value and save the attribute (possibly new)
applied_attr.value = value
applied_attr.save()
return applied_attr
def clear_attribute_value(self, identifier, language=None):
avail_attrs = self.get_available_attribute_queryset()
attr = avail_attrs.get(identifier=identifier)
attr_val = self.attributes.filter(attribute=attr).first()
if not attr_val:
return
if language is None: # Delete all translations
attr_val.delete()
return
trans = attr_val.translations.filter(language_code=language).first()
if trans:
trans.delete()
AttributeLogEntry = define_log_model(Attribute)
'is_active': user.is_active,
'first_name': getattr(user, 'first_name', ''),
'last_name': getattr(user, 'last_name', ''),
'email': getattr(user, 'email', ''),
}
return PersonContact.objects.get_or_create(user=user, defaults=defaults)[0]
def get_company_contact(user):
"""
Get preferred CompanyContact of given user.
If user has associated PersonContact which is member of
CompanyContact, return CompanyContact. Otherwise, return None.
:param user: User object (or None) to get contact for
:type user: django.contrib.auth.models.User|None
:return:
CompanyContact (or none) of which user's PersonContact is a member
:rtype: CompanyContact|None
"""
contact = get_person_contact(user)
if not contact:
return None
return contact.company_memberships.filter(is_active=True).first()
CompanyContactLogEntry = define_log_model(CompanyContact)
PersonContactLogEntry = define_log_model(PersonContact)
ContactGroupLogEntry = define_log_model(ContactGroup)
order_line = models.ForeignKey(OrderLine,
related_name='taxes',
on_delete=models.PROTECT,
verbose_name=_('order line'))
tax = models.ForeignKey("Tax",
related_name="order_line_taxes",
on_delete=models.PROTECT,
verbose_name=_('tax'))
name = models.CharField(max_length=200, verbose_name=_('tax name'))
amount = MoneyProperty('amount_value', 'order_line.order.currency')
base_amount = MoneyProperty('base_amount_value',
'order_line.order.currency')
amount_value = MoneyValueField(verbose_name=_('tax amount'))
base_amount_value = MoneyValueField(
verbose_name=_('base amount'),
help_text=_('Amount that this tax is calculated from'))
ordering = models.IntegerField(default=0, verbose_name=_('ordering'))
class Meta:
ordering = ["ordering"]
def __str__(self):
return "%s: %s on %s" % (self.name, self.amount, self.base_amount)
OrderLineLogEntry = define_log_model(OrderLine)
OrderLineTaxLogEntry = define_log_model(OrderLineTax)
verbose_name_plural = _("currencies")
def __str__(self):
return self.code
def get_currency_precision(currency):
"""
Get precision by currency code.
Precision values will be populated from the ``decimal_places``
fields of the `Currency` objects in the database.
:type currency: str
:param currency: Currency code as 3-letter string (ISO-4217)
:rtype: decimal.Decimal|None
:return: Precision value for given currency code or None for unknown
"""
cache_key = 'currency_precision:' + currency
precision = cache.get(cache_key)
if precision is None:
currency_obj = Currency.objects.filter(code=currency).first()
precision = (decimal.Decimal('0.1')**currency_obj.decimal_places
if currency_obj else None)
cache.set(cache_key, precision)
return precision
CurrencyLogEntry = define_log_model(Currency)
@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(
"WSHOP_SHOP_PRODUCT_SUPPLIERS_STRATEGY")
kwargs = {
"shop_product": self,
"customer": customer,
"quantity": quantity,
"shipping_address": shipping_address
}
return supplier_strategy().get_supplier(**kwargs)
ShopProductLogEntry = define_log_model(ShopProduct)
