def get_variant_availability(
variant: ProductVariant, discounts=None, taxes=None, local_currency=None
) -> VariantAvailability:
discounted = variant.get_price(discounts=discounts, taxes=taxes)
undiscounted = variant.get_price(taxes=taxes)
discount = _get_total_discount(undiscounted, discounted)
if local_currency:
price_local_currency = to_local_currency(discounted, local_currency)
discount_local_currency = to_local_currency(discount, local_currency)
else:
price_local_currency = None
discount_local_currency = None
is_on_sale = variant.is_visible and discount is not None
return VariantAvailability(
available=variant.is_available,
on_sale=is_on_sale,
price=discounted,
price_undiscounted=undiscounted,
discount=discount,
price_local_currency=price_local_currency,
discount_local_currency=discount_local_currency,
)
def test_update_products_minimal_variant_prices_of_catalogues_for_product(
product):
variant = ProductVariant(
product=product,
sku="SKU_MINIMAL_VARIANT_PRICE",
price_override=Money("0.99", "USD"),
)
variant.save()
product.refresh_from_db()
assert product.minimal_variant_price == product.price == Money("10", "USD")
update_products_minimal_variant_prices_of_catalogues(
product_ids=[product.pk])
product.refresh_from_db()
assert product.minimal_variant_price == variant.price_override
def test_update_products_minimal_variant_prices_of_catalogues_for_collection(
collection, product
):
variant = ProductVariant(
product=product,
sku="SKU_MINIMAL_VARIANT_PRICE",
price_override=Money("0.79", "MXN"),
)
variant.save()
product.refresh_from_db()
collection.products.add(product)
assert product.minimal_variant_price == product.price == Money("10", "MXN")
update_products_minimal_variant_prices_of_catalogues(collection_ids=[collection.pk])
product.refresh_from_db()
assert product.minimal_variant_price == variant.price_override
def test_product_variant_objects_bulk_create_updates_minimal_variant_price(
product):
assert product.minimal_variant_price == Money("10.00", "USD")
ProductVariant.objects.bulk_create([
ProductVariant(
product=product,
sku="1",
price_override=Money("1.00", "USD"),
quantity=1,
),
ProductVariant(
product=product,
sku="2",
price_override=Money("5.00", "USD"),
quantity=1,
),
])
product.refresh_from_db()
assert product.minimal_variant_price == Money("1.00", "USD")
def get_variant_availability(
variant: ProductVariant,
discounts: Iterable[DiscountInfo] = None,
country: Optional[str] = None,
local_currency: Optional[str] = None,
extensions: Optional["ExtensionsManager"] = None,
) -> VariantAvailability:
if not extensions:
extensions = get_extensions_manager()
discounted = extensions.apply_taxes_to_product(
variant.product, variant.get_price(discounts=discounts), country)
undiscounted = extensions.apply_taxes_to_product(variant.product,
variant.get_price(),
country)
discount = _get_total_discount(undiscounted, discounted)
if country is None:
country = settings.DEFAULT_COUNTRY
if local_currency:
price_local_currency = to_local_currency(discounted, local_currency)
discount_local_currency = to_local_currency(discount, local_currency)
else:
price_local_currency = None
discount_local_currency = None
is_on_sale = variant.is_visible and discount is not None
return VariantAvailability(
on_sale=is_on_sale,
price=discounted,
price_undiscounted=undiscounted,
discount=discount,
price_local_currency=price_local_currency,
discount_local_currency=discount_local_currency,
)
def test_variant_pricing(variant: ProductVariant, monkeypatch, settings,
taxes):
pricing = get_variant_availability(variant)
assert pricing.price == variant.get_price()
assert pricing.price_local_currency is None
monkeypatch.setattr('django_prices_openexchangerates.models.get_rates',
lambda c: {'PLN': Mock(rate=2)})
settings.DEFAULT_COUNTRY = 'PL'
settings.OPENEXCHANGERATES_API_KEY = 'fake-key'
pricing = get_variant_availability(variant, local_currency='PLN')
assert pricing.price_local_currency.currency == 'PLN'
assert pricing.available
pricing = get_variant_availability(variant, taxes=taxes)
assert pricing.price.tax.amount
assert pricing.price_undiscounted.tax.amount
assert pricing.price_undiscounted.tax.amount
assert pricing.available
def get_variant_availability_status(
variant: ProductVariant, ) -> VariantAvailabilityStatus:
if not variant.is_in_stock():
return VariantAvailabilityStatus.OUT_OF_STOCK
return VariantAvailabilityStatus.AVAILABLE
def product_list(product_type, category):
product_attr = product_type.product_attributes.first()
attr_value = product_attr.values.first()
products = list(
Product.objects.bulk_create(
[
Product(
pk=1486,
name="Test product 1",
price=Money(10, "USD"),
category=category,
product_type=product_type,
is_published=True,
),
Product(
pk=1487,
name="Test product 2",
price=Money(20, "USD"),
category=category,
product_type=product_type,
is_published=False,
),
Product(
pk=1489,
name="Test product 3",
price=Money(20, "USD"),
category=category,
product_type=product_type,
is_published=True,
),
]
)
)
ProductVariant.objects.bulk_create(
[
ProductVariant(
product=products[0],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
quantity=100,
),
ProductVariant(
product=products[1],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
quantity=100,
),
ProductVariant(
product=products[2],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
quantity=100,
),
]
)
for product in products:
associate_attribute_values_to_instance(product, product_attr, attr_value)
return products
def handle(self, *args, **options):
with open('{}/products.csv'.format(settings.PROJECT_ROOT),
encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
pk = row['id']
sku = row['sku']
print('Trying to add product ({})'.format(sku))
name = row['name']
description = row['description']
price = row['price']
stock_quantity = row['stock']
is_published = MAP_BOOLEANS[row['is_published']]
category = row['category']
product_type = row['type']
variant_name = row['variant_name']
variant_price = row['variant_price']
attribute = slugify(row['attribute'])
attribute_slug = slugify(attribute)
attribute_value = row['attribute_value']
attribute_value_slug = slugify(attribute_value)
try:
product_var = ProductVariant.objects.get(sku=sku)
except ProductVariant.DoesNotExist:
product_var = ProductVariant(sku=sku)
except ProductVariant.MultipleObjectsReturned:
print(
'Revise sku ({}), multiple product variants returned'.
format(sku))
continue
product_var.quantity = stock_quantity
try:
product = Product.objects.get(id=pk)
except Product.DoesNotExist:
product = Product(id=pk)
except Product.MultipleObjectsReturned:
print('Revise id ({}), multiple product variants returned'.
format(pk))
continue
try:
product_type = ProductType.objects.get(name=product_type)
except ProductType.DoesNotExist:
print(
'Product type ({}) for product ({}) does not exist, creating...'
.format(product_type, name))
product_type = ProductType.objects.create(
name=product_type)
product.product_type = product_type
try:
category = Category.objects.get(slug=category)
except Category.DoesNotExist:
print(
'Category ({}) for product ({}) does not exist, creating...'
.format(category, name))
category = Category.objects.create(slug=category,
name=category.title())
product.category = category
product.name = name
product.description = description
product.price = price
product.is_published = is_published
if variant_name:
product_var.name = variant_name
if variant_price:
product_var.price_override = variant_price
try:
product_attribute = ProductAttribute.objects.get(
slug=attribute_slug)
except ProductAttribute.DoesNotExist:
print(
'Product attribute ({}) for product ({}) does not exist, creating...'
.format(attribute, name))
product_attribute = ProductAttribute.objects.create(
slug=attribute_slug, name=attribute.title())
try:
product_attribute_value = AttributeChoiceValue.objects.get(
slug=attribute_value_slug)
except AttributeChoiceValue.DoesNotExist:
product_attribute_value = AttributeChoiceValue()
product_attribute_value.attribute = product_attribute
product_attribute_value.slug = attribute_value_slug
product_attribute_value.name = attribute_value.title()
product_attribute_value.save()
product_var_attrs = dict()
product_var_attrs[
product_attribute.pk] = product_attribute_value.pk
product_var.attributes = product_var_attrs
product_var.product = product
try:
product.save()
except Exception:
import pdb
pdb.set_trace()
product_var.save()
print('Product added successfully')
def products_for_pagination(product_type, color_attribute, category,
warehouse):
product_type2 = ProductType.objects.create(name="Apple")
products = Product.objects.bulk_create([
Product(
name="Product1",
slug="prod1",
price=Money("10.00", "USD"),
category=category,
product_type=product_type2,
is_published=True,
description="desc1",
),
Product(
name="ProductProduct1",
slug="prod_prod1",
price=Money("15.00", "USD"),
category=category,
product_type=product_type,
is_published=False,
),
Product(
name="ProductProduct2",
slug="prod_prod2",
price=Money("8.00", "USD"),
category=category,
product_type=product_type2,
is_published=True,
),
Product(
name="Product2",
slug="prod2",
price=Money("7.00", "USD"),
category=category,
product_type=product_type,
is_published=False,
description="desc2",
),
Product(
name="Product3",
slug="prod3",
price=Money("15.00", "USD"),
category=category,
product_type=product_type2,
is_published=True,
description="desc3",
),
])
product_attrib_values = color_attribute.values.all()
associate_attribute_values_to_instance(products[1], color_attribute,
product_attrib_values[0])
associate_attribute_values_to_instance(products[3], color_attribute,
product_attrib_values[1])
variants = ProductVariant.objects.bulk_create([
ProductVariant(
product=products[0],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
),
ProductVariant(
product=products[2],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
),
ProductVariant(
product=products[4],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
),
])
Stock.objects.bulk_create([
Stock(warehouse=warehouse, product_variant=variants[0], quantity=100),
Stock(warehouse=warehouse, product_variant=variants[1], quantity=0),
Stock(warehouse=warehouse, product_variant=variants[2], quantity=0),
])
return products