def create_order(self, order_source):
data = self.get_source_base_data(order_source)
order = Order(**data)
order.save()
order = self.finalize_creation(order, order_source)
order_creator_finished.send(sender=type(self), order=order, source=order_source)
return order
def test_order_address_immutability_unsaved_address(save):
billing_address = get_address()
if save:
billing_address.save()
order = Order(shop=get_default_shop(),
billing_address=billing_address.to_immutable(),
order_date=now(),
status=get_initial_order_status())
order.save()
order.billing_address.name = "Mute Doge"
with pytest.raises(ValidationError):
order.billing_address.save()
def test_order_address_immutability_unsaved_address(save):
billing_address = get_address()
if save:
billing_address.save()
order = Order(
shop=get_default_shop(),
billing_address=billing_address,
order_date=now(),
status=get_initial_order_status()
)
order.save()
order.billing_address.name = "Mute Doge"
with pytest.raises(ImmutabilityError):
order.billing_address.save()
def create_empty_order():
order = Order(shop=get_default_shop(),
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=get_address(name="Mony Doge"),
shipping_address=get_address(name="Shippy Doge"),
order_date=now(),
status=get_initial_order_status())
return order
def create_empty_order(prices_include_tax=False, shop=None):
order = Order(shop=(shop
or get_shop(prices_include_tax=prices_include_tax)),
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=get_address(name="Mony Doge"),
shipping_address=get_address(name="Shippy Doge"),
order_date=now(),
status=get_initial_order_status())
return order
def _get_order_line(request):
order = Order(
shop=request.shop,
currency=request.shop.currency,
prices_include_tax=request.shop.prices_include_tax,
)
pi = _get_price_info(request.shop, Product(sku='6.0745'), quantity=2)
return OrderLine(
order=order,
base_unit_price=pi.base_unit_price,
discount_amount=pi.discount_amount,
quantity=pi.quantity,
)
def create_order(request, creator, customer, product):
billing_address = get_address().to_immutable()
shipping_address = get_address(name="Shippy Doge").to_immutable()
shipping_address.save()
shop = request.shop
order = Order(
creator=creator,
customer=customer,
shop=shop,
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=billing_address,
shipping_address=shipping_address,
order_date=now(),
status=get_initial_order_status(),
currency=shop.currency,
prices_include_tax=shop.prices_include_tax,
)
order.full_clean()
order.save()
supplier = get_default_supplier()
product_order_line = OrderLine(order=order)
update_order_line_from_product(
pricing_context=request, order_line=product_order_line, product=product, quantity=5, supplier=supplier
)
product_order_line.base_unit_price = shop.create_price(100)
assert product_order_line.price.value > 0
product_order_line.save()
line_tax = get_line_taxes_for(product_order_line)[0]
product_order_line.taxes.add(
OrderLineTax.from_tax(tax=line_tax.tax, base_amount=line_tax.base_amount, order_line=product_order_line)
)
discount_order_line = OrderLine(order=order, quantity=1, type=OrderLineType.OTHER)
discount_order_line.discount_amount = shop.create_price(30)
assert discount_order_line.discount_amount.value == 30
assert discount_order_line.price.value == -30
assert discount_order_line.base_unit_price.value == 0
discount_order_line.save()
order.cache_prices()
order.check_all_verified()
order.save()
base = 5 * shop.create_price(100).amount
discount = shop.create_price(30).amount
tax_value = line_tax.amount
if not order.prices_include_tax:
assert order.taxless_total_price.amount == base - discount
assert order.taxful_total_price.amount == base + tax_value - discount
else:
assert_almost_equal(order.taxless_total_price.amount, base - tax_value - discount)
assert_almost_equal(order.taxful_total_price.amount, base - discount)
shipment = order.create_shipment_of_all_products(supplier=supplier)
assert shipment.total_products == 5, "All products were shipped"
assert shipment.weight == product.net_weight * 5, "Gravity works"
assert not order.get_unshipped_products(), "Nothing was left in the warehouse"
order.create_payment(order.taxful_total_price)
assert order.is_paid()
assert Order.objects.paid().filter(pk=order.pk).exists(), "It was paid! Honestly!"
def create_order(self, order_source):
# order_provision.target_user = self._maybe_create_user(
# user=order_provision.target_user,
# billing_address=order_provision.billing_address,
# shipping_address=order_provision.shipping_address
# )
order = Order(
shop=order_source.shop,
currency=order_source.currency,
prices_include_tax=order_source.prices_include_tax,
shipping_method=order_source.shipping_method,
payment_method=order_source.payment_method,
customer_comment=order_source.customer_comment,
marketing_permission=bool(order_source.marketing_permission),
ip_address=(self.request.META.get("REMOTE_ADDR") if self.request else None),
creator=real_user_or_none(order_source.creator),
orderer=(order_source.orderer or None),
customer=(order_source.customer or None),
billing_address=(order_source.billing_address.to_immutable() if order_source.billing_address else None),
shipping_address=(order_source.shipping_address.to_immutable() if order_source.shipping_address else None),
order_date=order_source.order_date,
status=order_source.status,
payment_data=order_source.payment_data,
shipping_data=order_source.shipping_data,
extra_data=order_source.extra_data,
)
order.save()
self.process_order_before_lines(source=order_source, order=order)
lines = self.get_source_order_lines(source=order_source, order=order)
self.add_lines_into_order(order, lines)
if any(line.require_verification for line in order.lines.all()):
order.require_verification = True
order.all_verified = False
else:
order.all_verified = True
order.cache_prices()
order.save()
self._assign_code_usages(order_source, order)
order_creator_finished.send(OrderCreator, order=order, source=order_source, request=self.request)
order.save()
self.process_order_after_lines(source=order_source, order=order)
# Then do all the caching one more time!
order.cache_prices()
order.save()
return order
def create_order(request, creator, customer, product):
billing_address = get_address().to_immutable()
shipping_address = get_address(name="Shippy Doge").to_immutable()
shipping_address.save()
shop = request.shop
order = Order(
creator=creator,
customer=customer,
shop=shop,
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=billing_address,
shipping_address=shipping_address,
order_date=now(),
status=get_initial_order_status(),
currency=shop.currency,
prices_include_tax=shop.prices_include_tax,
)
order.full_clean()
order.save()
supplier = get_default_supplier()
product_order_line = OrderLine(order=order)
update_order_line_from_product(pricing_context=request,
order_line=product_order_line,
product=product,
quantity=5,
supplier=supplier)
assert product_order_line.text == product.safe_translation_getter("name")
product_order_line.base_unit_price = shop.create_price(100)
assert product_order_line.price.value > 0
product_order_line.save()
line_tax = get_line_taxes_for(product_order_line)[0]
product_order_line.taxes.add(
OrderLineTax.from_tax(
tax=line_tax.tax,
base_amount=line_tax.base_amount,
order_line=product_order_line,
))
discount_order_line = OrderLine(order=order,
quantity=1,
type=OrderLineType.OTHER)
discount_order_line.discount_amount = shop.create_price(30)
assert discount_order_line.discount_amount.value == 30
assert discount_order_line.price.value == -30
assert discount_order_line.base_unit_price.value == 0
discount_order_line.save()
order.cache_prices()
order.check_all_verified()
order.save()
base = 5 * shop.create_price(100).amount
discount = shop.create_price(30).amount
tax_value = line_tax.amount
if not order.prices_include_tax:
assert order.taxless_total_price.amount == base - discount
assert order.taxful_total_price.amount == base + tax_value - discount
else:
assert_almost_equal(order.taxless_total_price.amount,
base - tax_value - discount)
assert_almost_equal(order.taxful_total_price.amount, base - discount)
shipment = order.create_shipment_of_all_products(supplier=supplier)
assert shipment.total_products == 5, "All products were shipped"
assert shipment.weight == product.net_weight * 5, "Gravity works"
assert not order.get_unshipped_products(
), "Nothing was left in the warehouse"
order.create_payment(order.taxful_total_price)
assert order.is_paid()
assert Order.objects.paid().filter(
pk=order.pk).exists(), "It was paid! Honestly!"
def create_order(self, order_source):
# order_provision.target_user = self._maybe_create_user(
# user=order_provision.target_user,
# billing_address=order_provision.billing_address,
# shipping_address=order_provision.shipping_address
# )
if order_source.billing_address and not order_source.billing_address.pk:
order_source.billing_address.save()
if order_source.shipping_address and not order_source.shipping_address.pk:
order_source.shipping_address.save()
order = Order(
shop=order_source.shop,
shipping_method=order_source.shipping_method,
payment_method=order_source.payment_method,
customer_comment=order_source.customer_comment,
marketing_permission=bool(order_source.marketing_permission),
ip_address=(self.request.META.get("REMOTE_ADDR")
if self.request else None),
creator=real_user_or_none(self.get_creator(order_source)),
orderer=(order_source.orderer or None),
customer=(order_source.customer or None),
billing_address=order_source.billing_address,
shipping_address=order_source.shipping_address,
order_date=order_source.order_date,
status=order_source.status,
payment_data=order_source.payment_data,
shipping_data=order_source.shipping_data,
extra_data=order_source.extra_data)
order.save()
self.process_order_before_lines(source=order_source, order=order)
lines = self.get_source_order_lines(source=order_source, order=order)
self.add_lines_into_order(order, lines)
if any(line.require_verification for line in order.lines.all()):
order.require_verification = True
order.all_verified = False
else:
order.all_verified = True
order.cache_prices()
order.save()
order_creator_finished.send(OrderCreator,
order=order,
source=order_source,
request=self.request)
order.save()
self.process_order_after_lines(source=order_source, order=order)
# Then do all the caching one more time!
order.cache_prices()
order.save()
return order
def create_order(self, order_source):
order = Order(
shop=order_source.shop,
currency=order_source.currency,
prices_include_tax=order_source.prices_include_tax,
shipping_method=order_source.shipping_method,
payment_method=order_source.payment_method,
customer_comment=order_source.customer_comment,
marketing_permission=bool(order_source.marketing_permission),
ip_address=order_source.ip_address,
creator=real_user_or_none(order_source.creator),
orderer=(order_source.orderer or None),
customer=(order_source.customer or None),
billing_address=(order_source.billing_address.to_immutable()
if order_source.billing_address else None),
shipping_address=(order_source.shipping_address.to_immutable()
if order_source.shipping_address else None),
order_date=order_source.order_date,
status=order_source.status,
payment_data=order_source.payment_data,
shipping_data=order_source.shipping_data,
extra_data=order_source.extra_data)
order.save()
self.process_order_before_lines(source=order_source, order=order)
lines = self.get_source_order_lines(source=order_source, order=order)
self.add_lines_into_order(order, lines)
if any(line.require_verification for line in order.lines.all()):
order.require_verification = True
order.all_verified = False
else:
order.all_verified = True
order.cache_prices()
order.save()
if order.customer and order.customer.marketing_permission != order.marketing_permission:
order.customer.marketing_permission = order.marketing_permission
order.customer.save(update_fields=["marketing_permission"])
self._assign_code_usages(order_source, order)
order_creator_finished.send(sender=type(self),
order=order,
source=order_source)
order.save()
self.process_order_after_lines(source=order_source, order=order)
# Then do all the caching one more time!
order.cache_prices()
order.save()
return order
def create_order(request, creator, customer, product):
billing_address = get_address()
shipping_address = get_address(name="Shippy Doge")
shipping_address.save()
order = Order(creator=creator,
customer=customer,
shop=get_default_shop(),
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=billing_address,
shipping_address=shipping_address,
order_date=now(),
status=get_initial_order_status())
order.full_clean()
order.save()
supplier = get_default_supplier()
product_order_line = OrderLine(order=order)
update_order_line_from_product(order_line=product_order_line,
product=product,
request=request,
quantity=5,
supplier=supplier)
product_order_line.unit_price = TaxlessPrice(100)
assert product_order_line.taxful_total_price.amount > 0
product_order_line.save()
product_order_line.taxes.add(
OrderLineTax.from_tax(get_default_tax(),
product_order_line.taxless_total_price))
discount_order_line = OrderLine(order=order,
quantity=1,
type=OrderLineType.OTHER)
discount_order_line.total_discount = TaxfulPrice(30)
assert discount_order_line.taxful_total_discount.amount == 30
assert discount_order_line.taxful_total_price.amount == -30
assert discount_order_line.taxful_unit_price.amount == 0
discount_order_line.save()
order.cache_prices()
order.check_all_verified()
order.save()
base_amount = 5 * 100
tax_value = get_default_tax().calculate_amount(base_amount)
assert order.taxful_total_price == base_amount + tax_value - 30, "Math works"
shipment = order.create_shipment_of_all_products(supplier=supplier)
assert shipment.total_products == 5, "All products were shipped"
assert shipment.weight == product.net_weight * 5, "Gravity works"
assert not order.get_unshipped_products(
), "Nothing was left in the warehouse"
order.create_payment(order.taxful_total_price)
assert order.is_paid()
assert Order.objects.paid().filter(
pk=order.pk).exists(), "It was paid! Honestly!"
def create_order(self, order_source):
order = Order(
shop=order_source.shop,
currency=order_source.currency,
prices_include_tax=order_source.prices_include_tax,
shipping_method=order_source.shipping_method,
payment_method=order_source.payment_method,
customer_comment=order_source.customer_comment,
marketing_permission=bool(order_source.marketing_permission),
ip_address=order_source.ip_address,
creator=real_user_or_none(order_source.creator),
orderer=(order_source.orderer or None),
customer=(order_source.customer or None),
billing_address=(order_source.billing_address.to_immutable() if order_source.billing_address else None),
shipping_address=(order_source.shipping_address.to_immutable() if order_source.shipping_address else None),
order_date=order_source.order_date,
status=order_source.status,
payment_data=order_source.payment_data,
shipping_data=order_source.shipping_data,
extra_data=order_source.extra_data
)
order.save()
self.process_order_before_lines(source=order_source, order=order)
lines = self.get_source_order_lines(source=order_source, order=order)
self.add_lines_into_order(order, lines)
if any(line.require_verification for line in order.lines.all()):
order.require_verification = True
order.all_verified = False
else:
order.all_verified = True
order.cache_prices()
order.save()
if order.customer and order.customer.marketing_permission != order.marketing_permission:
order.customer.marketing_permission = order.marketing_permission
order.customer.save(update_fields=["marketing_permission"])
self._assign_code_usages(order_source, order)
order_creator_finished.send(
sender=type(self), order=order, source=order_source)
order.save()
self.process_order_after_lines(source=order_source, order=order)
# Then do all the caching one more time!
order.cache_prices()
order.save()
return order
def create_order(request, creator, customer, product):
billing_address = get_address()
shipping_address = get_address(name="Shippy Doge")
shipping_address.save()
order = Order(
creator=creator,
customer=customer,
shop=get_default_shop(),
payment_method=get_default_payment_method(),
shipping_method=get_default_shipping_method(),
billing_address=billing_address,
shipping_address=shipping_address,
order_date=now(),
status=get_initial_order_status()
)
order.full_clean()
order.save()
supplier = get_default_supplier()
product_order_line = OrderLine(order=order)
update_order_line_from_product(order_line=product_order_line, product=product, request=request, quantity=5, supplier=supplier)
product_order_line.unit_price = TaxlessPrice(100)
assert product_order_line.taxful_total_price.amount > 0
product_order_line.save()
product_order_line.taxes.add(OrderLineTax.from_tax(get_default_tax(), product_order_line.taxless_total_price))
discount_order_line = OrderLine(order=order, quantity=1, type=OrderLineType.OTHER)
discount_order_line.total_discount = TaxfulPrice(30)
assert discount_order_line.taxful_total_discount.amount == 30
assert discount_order_line.taxful_total_price.amount == -30
assert discount_order_line.taxful_unit_price.amount == 0
discount_order_line.save()
order.cache_prices()
order.check_all_verified()
order.save()
base_amount = 5 * 100
tax_value = get_default_tax().calculate_amount(base_amount)
assert order.taxful_total_price == base_amount + tax_value - 30, "Math works"
shipment = order.create_shipment_of_all_products(supplier=supplier)
assert shipment.total_products == 5, "All products were shipped"
assert shipment.weight == product.net_weight * 5, "Gravity works"
assert not order.get_unshipped_products(), "Nothing was left in the warehouse"
order.create_payment(order.taxful_total_price)
assert order.is_paid()
assert Order.objects.paid().filter(pk=order.pk).exists(), "It was paid! Honestly!"
