def create_order(self):
basket = self.request.basket
assert isinstance(basket, BaseBasket)
assert basket.shop == self.request.shop
basket.orderer = self.request.person
basket.customer = self.request.customer
basket.creator = self.request.user
basket.status = OrderStatus.objects.get_default_initial()
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
return order
def create_order(self):
basket = self.request.basket
assert isinstance(basket, BaseBasket)
assert basket.shop == self.request.shop
basket.orderer = self.request.person
basket.customer = self.request.customer
basket.creator = self.request.user
basket.status = OrderStatus.objects.get_default_initial()
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
return order
def create_order(self):
basket = self.basket
assert basket.shop == self.request.shop
basket.orderer = self.request.person
basket.customer = self.request.customer
basket.creator = self.request.user
if "impersonator_user_id" in self.request.session:
basket.creator = get_user_model().objects.get(pk=self.request.session["impersonator_user_id"])
basket.status = OrderStatus.objects.get_default_initial()
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
return order
def create_order(self):
basket = self.basket
assert isinstance(basket, BaseBasket)
assert basket.shop == self.request.shop
basket.orderer = self.request.person
basket.customer = self.request.customer
basket.creator = self.request.user
if "impersonator_user_id" in self.request.session:
basket.creator = get_user_model().objects.get(pk=self.request.session["impersonator_user_id"])
basket.status = OrderStatus.objects.get_default_initial()
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
return order
def form_valid(self, form):
basket = self.request.basket
assert isinstance(basket, BaseBasket)
order_data = form["order"].cleaned_data.copy()
if not order_data.pop("accept_terms", None): # pragma: no cover
raise ValidationError("Terms must be accepted")
basket.shop = self.request.shop
basket.orderer = self.request.person
basket.customer = self.request.customer
basket.creator = self.request.user
if "impersonator_user_id" in self.request.session:
basket.creator = get_user_model().objects.get(
pk=self.request.session["impersonator_user_id"])
basket.shipping_address = form["shipping"].save(commit=False)
basket.billing_address = form["billing"].save(commit=False)
basket.shipping_method = order_data.pop("shipping_method")
basket.payment_method = order_data.pop("payment_method")
basket.status = OrderStatus.objects.get_default_initial()
company_name = order_data.pop("company_name")
tax_number = order_data.pop("tax_number")
if company_name and tax_number:
# Not using `get_or_create` here because duplicates are better than accidental information leakage
basket.customer = CompanyContact.objects.create(
name=company_name, tax_number=tax_number)
for address in (basket.shipping_address, basket.billing_address):
address.company_name = basket.customer.name
address.tax_number = basket.customer.tax_number
basket.marketing_permission = order_data.pop("marketing")
basket.customer_comment = order_data.pop("comment")
if order_data: # pragma: no cover
raise ValueError("`order_data` should be empty by now")
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
self.checkout_process.complete()
if order.require_verification:
return redirect("shuup:order_requires_verification",
pk=order.pk,
key=order.key)
else:
return redirect("shuup:order_process_payment",
pk=order.pk,
key=order.key)
def checkout(self, request, *args, **kwargs):
serializer = CheckoutSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
basket = self.get_basket()
basket.verify_orderability()
basket.shipping_method = serializer.validated_data['shipping_method']
basket.payment_method = serializer.validated_data['payment_method']
if basket.product_count < 1:
raise ValidationError({
'code': 'empty_basket',
'error': 'You can\'t order an empty basket'
})
basket.status = OrderStatus.objects.get_default_initial()
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
basket.save()
return Response(OrderSerializer(order).data)
def form_valid(self, form):
basket = self.request.basket
assert isinstance(basket, BaseBasket)
order_data = form["order"].cleaned_data.copy()
if not order_data.pop("accept_terms", None): # pragma: no cover
raise ValidationError("Terms must be accepted")
basket.shop = self.request.shop
basket.orderer = self.request.person
basket.customer = self.request.customer
basket.creator = self.request.user
if "impersonator_user_id" in self.request.session:
basket.creator = get_user_model().objects.get(pk=self.request.session["impersonator_user_id"])
basket.shipping_address = form["shipping"].save(commit=False)
basket.billing_address = form["billing"].save(commit=False)
basket.shipping_method = order_data.pop("shipping_method")
basket.payment_method = order_data.pop("payment_method")
basket.status = OrderStatus.objects.get_default_initial()
company_name = order_data.pop("company_name")
tax_number = order_data.pop("tax_number")
if company_name and tax_number:
# Not using `get_or_create` here because duplicates are better than accidental information leakage
basket.customer = CompanyContact.objects.create(name=company_name, tax_number=tax_number)
for address in (basket.shipping_address, basket.billing_address):
address.company_name = basket.customer.name
address.tax_number = basket.customer.tax_number
basket.marketing_permission = order_data.pop("marketing")
basket.customer_comment = order_data.pop("comment")
if order_data: # pragma: no cover
raise ValueError("`order_data` should be empty by now")
order_creator = get_basket_order_creator()
order = order_creator.create_order(basket)
basket.finalize()
self.checkout_process.complete()
if order.require_verification:
return redirect("shuup:order_requires_verification", pk=order.pk, key=order.key)
else:
return redirect("shuup:order_process_payment", pk=order.pk, key=order.key)
def test_simple_packager1(rf):
populate_if_required()
MAX_WIDTH = 1050
MAX_LENGTH = 1050
MAX_HEIGHT = 1050
MAX_EDGES_SUM = 2000
MAX_WEIGHT = 30000
constraint1 = SimplePackageDimensionConstraint(MAX_WIDTH, MAX_LENGTH,
MAX_HEIGHT, MAX_EDGES_SUM)
constraint2 = WeightPackageConstraint(MAX_WEIGHT)
packager = SimplePackager()
assert packager._constraints == set()
packager.add_constraint(constraint1)
packager.add_constraint(constraint2)
assert constraint1 in packager._constraints
assert constraint2 in packager._constraints
product1 = create_product(sku='p1',
width=250,
depth=200,
height=50,
gross_weight=2340,
shop=get_default_shop(),
supplier=get_default_supplier())
product2 = create_product(sku='p2',
width=500,
depth=150,
height=90,
gross_weight=690,
shop=get_default_shop(),
supplier=get_default_supplier())
assert packager._product_has_valid_attrs(product1) is True
assert packager._product_has_valid_attrs(product2) is True
# cria produtos invalidos, sem propriedades necessárias
# no gross_weight
product_invalid_1 = create_product(sku='pi1',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_1.gross_weight = 0
assert packager._product_has_valid_attrs(product_invalid_1) is False
# no height
product_invalid_2 = create_product(sku='pi2',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_2.height = 0
assert packager._product_has_valid_attrs(product_invalid_2) is False
# no depth
product_invalid_3 = create_product(sku='pi3',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_3.depth = 0
assert packager._product_has_valid_attrs(product_invalid_3) is False
# no width
product_invalid_4 = create_product(sku='pi4',
width=100,
depth=200,
height=50,
gross_weight=100)
product_invalid_4.width = 0
assert packager._product_has_valid_attrs(product_invalid_4) is False
# cria um basket vazio
request = rf.get("/")
request.session = {}
request.shop = get_default_shop()
apply_request_middleware(request)
basket = get_basket(request)
# adiciona um item no carrinho
basket.add_product(supplier=get_default_supplier(),
shop=get_default_shop(),
product=product1,
quantity=2)
basket.add_product(supplier=get_default_supplier(),
shop=get_default_shop(),
product=product2,
quantity=3)
# cria o pedido a partir do carrinho
order_creator = get_basket_order_creator()
basket.status = OrderStatus.objects.get_default_initial()
order = order_creator.create_order(basket)
packages_from_source = packager.pack_source(basket)
packages_from_order = packager.pack_order(order)
# os produtos cabem todos no mesmo pacote
assert len(packages_from_source) == 1
assert len(packages_from_order) == 1
pkge_from_source = packages_from_source[0]
pkge_from_order = packages_from_order[0]
for pkge in (pkge_from_source, pkge_from_order):
assert pkge.count == 5 # 5 produtos
assert pkge.weight == (product1.gross_weight * 2 +
product2.gross_weight * 3) # peso igual
assert pkge.width == 500 # product2 width
assert pkge.length == 200 # product1 depth
assert pkge.height == (product1.height * 2 + product2.height * 3
) # soma as alturas
