def get_selected_grouping_method(request):
"""Returns the selected grouping shipping method for the passed request.
"""
customer = customer_utils.get_customer(request)
if customer and customer.selected_grouping_method:
return customer.selected_grouping_method
else:
return get_default_grouping_method(request)
def get_selected_payment_method(request):
"""Returns the selected payment method for given request. This could either
be an explicitly selected payment method of the current user or the default
payment method.
"""
customer = customer_utils.get_customer(request)
if customer and customer.selected_payment_method:
return customer.selected_payment_method
else:
return get_default_payment_method(request)
def get_selected_payment_method(request):
"""Returns the selected payment method for given request. This could either
be an explicitly selected payment method of the current user or the default
payment method.
"""
customer = customer_utils.get_customer(request)
if customer and customer.selected_payment_method:
return customer.selected_payment_method
else:
return get_default_payment_method(request)
def get_selected_shipping_method(request):
"""Returns the selected shipping method for the passed request.
This could either be an explicitely selected shipping method of the current
user or the default shipping method.
"""
customer = customer_utils.get_customer(request)
if customer and customer.selected_shipping_method:
return customer.selected_shipping_method
else:
return get_default_shipping_method(request)
def _get_quote(self):
ups_cfg = self._ups_config()
credentials = {
'username': ups_cfg.username,
'password': ups_cfg.password,
'access_license': ups_cfg.access_license,
'shipper_number': ups_cfg.shipper_number,
}
shipper = Address(
name=ups_cfg.shipper_name,
address=ups_cfg.shipper_address,
city=ups_cfg.shipper_city,
state=ups_cfg.shipper_state,
zip=ups_cfg.shipper_zipcode,
country=ups_cfg.shipper_country.code
)
customer = get_customer(self.request)
ship_address = customer.get_selected_shipping_address()
recipient = Address(
name=' '.join([ship_address.firstname or '', ship_address.lastname or '']),
address=' '.join([ship_address.line1 or '', ship_address.line2 or '']),
city=ship_address.city,
state=ship_address.state,
zip=ship_address.zip_code,
country=ship_address.country.code
)
cart = get_cart(self.request)
#weight, length, width, height
product_info = [0, 0, 0, 0]
for line_item in cart.get_items():
product_info[0] += line_item.product.weight * line_item.amount
product_info[1] += line_item.product.length * line_item.amount
product_info[2] += line_item.product.width * line_item.amount
product_info[3] += line_item.product.height * line_item.amount
#import pdb; pdb.set_trace()
quote = 0.0
if all(product_info):
packages = [Package(*product_info)]
ups = UPSClient(credentials)
response = ups.rate(
packages=packages,
packaging_type=ups_cfg.default_packaging_type,
shipper=shipper,
recipient=recipient
)
quote = float(response['info'][0]['cost'])
return quote
def _get_quote(self):
ups_cfg = self._ups_config()
credentials = {
'username': ups_cfg.username,
'password': ups_cfg.password,
'access_license': ups_cfg.access_license,
'shipper_number': ups_cfg.shipper_number,
}
shipper = Address(name=ups_cfg.shipper_name,
address=ups_cfg.shipper_address,
city=ups_cfg.shipper_city,
state=ups_cfg.shipper_state,
zip=ups_cfg.shipper_zipcode,
country=ups_cfg.shipper_country.code)
customer = get_customer(self.request)
ship_address = customer.get_selected_shipping_address()
recipient = Address(name=' '.join(
[ship_address.firstname or '', ship_address.lastname or '']),
address=' '.join([
ship_address.line1 or '', ship_address.line2
or ''
]),
city=ship_address.city,
state=ship_address.state,
zip=ship_address.zip_code,
country=ship_address.country.code)
cart = get_cart(self.request)
#weight, length, width, height
product_info = [0, 0, 0, 0]
for line_item in cart.get_items():
product_info[0] += line_item.product.weight * line_item.amount
product_info[1] += line_item.product.length * line_item.amount
product_info[2] += line_item.product.width * line_item.amount
product_info[3] += line_item.product.height * line_item.amount
#import pdb; pdb.set_trace()
quote = 0.0
if all(product_info):
packages = [Package(*product_info)]
ups = UPSClient(credentials)
response = ups.rate(packages=packages,
packaging_type=ups_cfg.default_packaging_type,
shipper=shipper,
recipient=recipient)
quote = float(response['info'][0]['cost'])
return quote
def get_selected_shipping_country(request):
"""Returns the selected shipping country for the passed request.
This could either be an explicitely selected country of the current
user or the default country of the shop.
"""
customer = customer_utils.get_customer(request)
if customer:
if customer.selected_shipping_address:
return customer.selected_shipping_address.country
elif customer.selected_country:
return customer.selected_country
return lfs.core.utils.get_default_shop(request).get_default_country()
def get_customer_tax_rate(request, product):
"""Returns the specfic customer tax for the current customer and product.
"""
customer = get_customer(request)
try:
shipping_country = customer.selected_shipping_address.country
except AttributeError:
return _calc_product_tax_rate(request, product)
try:
customer_tax = CustomerTax.objects.get(countries=shipping_country)
except CustomerTax.DoesNotExist:
return _calc_product_tax_rate(request, product)
return customer_tax.rate
def _compute_price(self):
#Get the zip_code
customer = get_customer(self.request)
ship_address = customer.selected_shipping_address
zip_code = ship_address.zip_code
#Lookup the zone based on the ZIP Code and weight
if zip_code:
zone = get_zone(int(zip_code))
else:
zone = 8
cart = get_cart(self.request)
weight = 0
for item in cart.get_items():
weight += item.product.weight * item.amount
return get_price(zone, weight)
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
invoice_address = customer.selected_invoice_address
if request.POST.get("no_shipping"):
shipping_address = customer.selected_invoice_address
else:
shipping_address = customer.selected_shipping_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request, shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = customer.selected_invoice_address.email
# Calculate the totals
price = cart.get_price_gross(request) + shipping_costs["price_gross"] + payment_costs["price"]
tax = cart.get_tax(request) + shipping_costs["tax"] + payment_costs["tax"]
# Discounts
discounts = lfs.discounts.utils.get_valid_discounts(request)
for discount in discounts:
price = price - discount["price_gross"]
tax = tax - discount["tax"]
# Add voucher if one exists
is_voucher_effective = False
try:
voucher_number = lfs.voucher.utils.get_current_voucher_number(request)
voucher = Voucher.objects.get(number=voucher_number)
except Voucher.DoesNotExist:
voucher = None
else:
is_voucher_effective, voucher_message = voucher.is_effective(request, cart)
if is_voucher_effective:
voucher_number = voucher.number
voucher_price = voucher.get_price_gross(request, cart)
voucher_tax = voucher.get_tax(request, cart)
price -= voucher_price
tax -= voucher_tax
else:
voucher = None
if price < 0:
price = 0
if tax < 0:
tax = 0
# Copy addresses
invoice_address = deepcopy(invoice_address)
invoice_address.id = None
invoice_address.save()
shipping_address = deepcopy(shipping_address)
shipping_address.id = None
shipping_address.save()
order = Order.objects.create(
user=user,
session=request.session.session_key,
price=price,
tax=tax,
customer_firstname=customer.selected_invoice_address.firstname,
customer_lastname=customer.selected_invoice_address.lastname,
customer_email=customer_email,
shipping_method=shipping_method,
shipping_price=shipping_costs["price_gross"],
shipping_tax=shipping_costs["tax"],
payment_method=payment_method,
payment_price=payment_costs["price"],
payment_tax=payment_costs["tax"],
invoice_address=invoice_address,
shipping_address=shipping_address,
message=request.POST.get("message", ""),
)
invoice_address.order = order
invoice_address.save()
shipping_address.order = order
shipping_address.save()
requested_delivery_date = request.POST.get("requested_delivery_date", None)
if requested_delivery_date is not None:
order.requested_delivery_date = requested_delivery_date
order.save()
if is_voucher_effective:
voucher.mark_as_used()
order.voucher_number = voucher_number
order.voucher_price = voucher_price
order.voucher_tax = voucher_tax
order.save()
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.get_items():
if cart_item.amount == 0:
continue
order_item = OrderItem.objects.create(
order=order,
price_net=cart_item.get_price_net(request),
price_gross=cart_item.get_price_gross(request),
tax=cart_item.get_tax(request),
product=cart_item.product,
product_sku=cart_item.product.sku,
product_name=cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net=cart_item.product.get_price_net(request),
product_price_gross=cart_item.get_product_price_gross(request),
product_tax=cart_item.product.get_tax(request),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
# Copy properties to order
if cart_item.product.is_configurable_product():
for cpv in cart_item.properties.all():
OrderItemPropertyValue.objects.create(
order_item=order_item, property=cpv.property, value=cpv.value)
for discount in discounts:
OrderItem.objects.create(
order=order,
price_net=-discount["price_net"],
price_gross=-discount["price_gross"],
tax=-discount["tax"],
product_sku=discount["sku"],
product_name=discount["name"],
product_amount=1,
product_price_net=-discount["price_net"],
product_price_gross=-discount["price_gross"],
product_tax=-discount["tax"],
)
# Send signal before cart is deleted.
order_created.send({"order": order, "cart": cart, "request": request})
cart.delete()
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
ong = import_symbol(settings.LFS_ORDER_NUMBER_GENERATOR)
try:
order_numbers = ong.objects.get(id="order_number")
except ong.DoesNotExist:
order_numbers = ong.objects.create(id="order_number")
try:
order_numbers.init(request, order)
except AttributeError:
pass
order.number = order_numbers.get_next()
order.save()
return order
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
invoice_address = customer.selected_invoice_address
if request.POST.get("no_shipping"):
shipping_address = customer.selected_invoice_address
else:
shipping_address = customer.selected_shipping_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request,
shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = customer.selected_invoice_address.email
# Calculate the totals
price = cart.get_price_gross(
request) + shipping_costs["price"] + payment_costs["price"]
tax = cart.get_tax(request) + shipping_costs["tax"] + payment_costs["tax"]
# Discounts
discounts = lfs.discounts.utils.get_valid_discounts(request)
for discount in discounts:
price = price - discount["price"]
tax = tax - discount["tax"]
# Add voucher if one exists
try:
voucher_number = lfs.voucher.utils.get_current_voucher_number(request)
voucher = Voucher.objects.get(number=voucher_number)
except Voucher.DoesNotExist:
voucher = None
else:
is_voucher_effective, voucher_message = voucher.is_effective(
request, cart)
if is_voucher_effective:
voucher_number = voucher.number
voucher_price = voucher.get_price_gross(request, cart)
voucher_tax = voucher.get_tax(request, cart)
price -= voucher_price
tax -= voucher_tax
else:
voucher = None
order = Order.objects.create(
user=user,
session=request.session.session_key,
price=price,
tax=tax,
customer_firstname=customer.selected_invoice_address.firstname,
customer_lastname=customer.selected_invoice_address.lastname,
customer_email=customer_email,
shipping_method=shipping_method,
shipping_price=shipping_costs["price"],
shipping_tax=shipping_costs["tax"],
payment_method=payment_method,
payment_price=payment_costs["price"],
payment_tax=payment_costs["tax"],
invoice_firstname=customer.selected_invoice_address.firstname,
invoice_lastname=customer.selected_invoice_address.lastname,
invoice_company_name=customer.selected_invoice_address.company_name,
invoice_line1=invoice_address.line1,
invoice_line2=invoice_address.line2,
invoice_city=invoice_address.city,
invoice_state=invoice_address.state,
invoice_code=invoice_address.zip_code,
invoice_country=Country.objects.get(code=invoice_address.country.code),
invoice_phone=customer.selected_invoice_address.phone,
shipping_firstname=shipping_address.firstname,
shipping_lastname=shipping_address.lastname,
shipping_company_name=shipping_address.company_name,
shipping_line1=shipping_address.line1,
shipping_line2=shipping_address.line2,
shipping_city=shipping_address.city,
shipping_state=shipping_address.state,
shipping_code=shipping_address.zip_code,
shipping_country=Country.objects.get(
code=shipping_address.country.code),
shipping_phone=shipping_address.phone,
message=request.POST.get("message", ""),
)
requested_delivery_date = request.POST.get("requested_delivery_date", None)
if requested_delivery_date is not None:
order.requested_delivery_date = requested_delivery_date
order.save()
if voucher:
voucher.mark_as_used()
order.voucher_number = voucher_number
order.voucher_price = voucher_price
order.voucher_tax = voucher_tax
order.save()
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.get_items():
order_item = OrderItem.objects.create(
order=order,
price_net=cart_item.get_price_net(request),
price_gross=cart_item.get_price_gross(request),
tax=cart_item.get_tax(request),
product=cart_item.product,
product_sku=cart_item.product.sku,
product_name=cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net=cart_item.product.get_price_net(request),
product_price_gross=cart_item.get_product_price_gross(request),
product_tax=cart_item.product.get_tax(request),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
# Copy properties to order
if cart_item.product.is_configurable_product():
for cpv in cart_item.properties.all():
OrderItemPropertyValue.objects.create(order_item=order_item,
property=cpv.property,
value=cpv.value)
for discount in discounts:
OrderItem.objects.create(
order=order,
price_net=-(discount["price"] - discount["tax"]),
price_gross=-discount["price"],
tax=-discount["tax"],
product_sku=discount["sku"],
product_name=discount["name"],
product_amount=1,
product_price_net=-(discount["price"] - discount["tax"]),
product_price_gross=-discount["price"],
product_tax=-discount["tax"],
)
# Send signal before cart is deleted.
order_created.send({"order": order, "cart": cart, "request": request})
cart.delete()
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
ong = import_symbol(settings.LFS_ORDER_NUMBER_GENERATOR)
try:
order_numbers = ong.objects.get(id="order_number")
except ong.DoesNotExist:
order_numbers = ong.objects.create(id="order_number")
try:
order_numbers.init(request, order)
except AttributeError:
pass
order.number = order_numbers.get_next()
order.save()
return order
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
not_required_address = getattr(settings, 'LFS_CHECKOUT_NOT_REQUIRED_ADDRESS', 'shipping')
invoice_address = customer.selected_invoice_address
shipping_address = customer.selected_shipping_address
if not_required_address == 'shipping':
if request.POST.get("no_shipping"):
shipping_address = customer.selected_invoice_address
else:
shipping_address = customer.selected_shipping_address
else:
if request.POST.get("no_invoice"):
invoice_address = customer.selected_shipping_address
else:
invoice_address = customer.selected_invoice_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request, shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = customer.selected_invoice_address.email
# Calculate the totals
price = cart.get_price_gross(request) + shipping_costs["price_gross"] + payment_costs["price"]
tax = cart.get_tax(request) + shipping_costs["tax"] + payment_costs["tax"]
# get voucher data (if voucher exists)
voucher_data = get_voucher_data(request, cart)
# get discounts data
discounts_data = lfs.discounts.utils.get_discounts_data(request)
# calculate total value of discounts and voucher that sum up
summed_up_value = discounts_data['summed_up_value']
if voucher_data['sums_up']:
summed_up_value += voucher_data['voucher_value']
# initialize discounts with summed up discounts
use_voucher = voucher_data['voucher'] is not None
discounts = discounts_data['summed_up_discounts']
if voucher_data['voucher_value'] > summed_up_value or discounts_data['max_value'] > summed_up_value:
# use not summed up value
if voucher_data['voucher_value'] > discounts_data['max_value']:
# use voucher only
discounts = []
else:
# use discount only
discounts = discounts_data['max_discounts']
use_voucher = False
for discount in discounts:
price -= discount["price_gross"]
tax -= discount["tax"]
if use_voucher:
price -= voucher_data['voucher_value']
tax -= voucher_data['voucher_tax']
if price < 0:
price = 0
if tax < 0:
tax = 0
# Copy addresses
invoice_address = deepcopy(invoice_address)
invoice_address.id = None
invoice_address.pk = None
invoice_address.save()
shipping_address = deepcopy(shipping_address)
shipping_address.id = None
shipping_address.pk = None
shipping_address.save()
order = Order.objects.create(
user=user,
session=request.session.session_key,
price=price,
tax=tax,
customer_firstname=customer.selected_invoice_address.firstname,
customer_lastname=customer.selected_invoice_address.lastname,
customer_email=customer_email,
shipping_method=shipping_method,
shipping_price=shipping_costs["price_gross"],
shipping_tax=shipping_costs["tax"],
payment_method=payment_method,
payment_price=payment_costs["price"],
payment_tax=payment_costs["tax"],
invoice_address=invoice_address,
shipping_address=shipping_address,
message=request.POST.get("message", ""),
)
delivery_time = cart.get_delivery_time(request)
if delivery_time:
OrderDeliveryTime.objects.create(order=order, min=delivery_time.min, max=delivery_time.max, unit=delivery_time.unit)
invoice_address.order = order
invoice_address.save()
shipping_address.order = order
shipping_address.save()
requested_delivery_date = request.POST.get("requested_delivery_date", None)
if requested_delivery_date is not None:
order.requested_delivery_date = requested_delivery_date
order.save()
if use_voucher:
voucher_data['voucher'].mark_as_used()
order.voucher_number = voucher_data['voucher_number']
order.voucher_price = voucher_data['voucher_value']
order.voucher_tax = voucher_data['voucher_tax']
order.save()
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.get_items():
if cart_item.amount == 0:
continue
order_item = OrderItem.objects.create(
order=order,
price_net=cart_item.get_price_net(request),
price_gross=cart_item.get_price_gross(request),
tax=cart_item.get_tax(request),
product=cart_item.product,
product_sku=cart_item.product.sku,
product_name=cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net=cart_item.product.get_price_net(request),
product_price_gross=cart_item.get_product_price_gross(request),
product_tax=cart_item.product.get_tax(request),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
# Copy properties to order
if cart_item.product.is_configurable_product():
for cpv in cart_item.properties.all():
OrderItemPropertyValue.objects.create(
order_item=order_item, property=cpv.property, value=cpv.value)
for discount in discounts:
OrderItem.objects.create(
order=order,
price_net=-discount["price_net"],
price_gross=-discount["price_gross"],
tax=-discount["tax"],
product_sku=discount["sku"],
product_name=discount["name"],
product_amount=1,
product_price_net=-discount["price_net"],
product_price_gross=-discount["price_gross"],
product_tax=-discount["tax"],
)
# Re-initialize selected addresses to be equal to default addresses for next order
customer.sync_default_to_selected_addresses()
customer.save()
# Send signal before cart is deleted.
order_created.send(order, cart=cart, request=request)
cart.delete()
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
ong = import_symbol(settings.LFS_ORDER_NUMBER_GENERATOR)
try:
order_numbers = ong.objects.get(id="order_number")
except ong.DoesNotExist:
order_numbers = ong.objects.create(id="order_number")
try:
order_numbers.init(request, order)
except AttributeError:
pass
order.number = order_numbers.get_next()
order.save()
return order
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
invoice_address = customer.selected_invoice_address
if customer.selected_shipping_address:
shipping_address = customer.selected_shipping_address
else:
shipping_address = customer.selected_invoice_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
cart_costs = cart_utils.get_cart_costs(request, cart, total=False)
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request, shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = invoice_address.email
# Calculate the totals
price = cart_costs["price"] + shipping_costs["price"] + payment_costs["price"]
tax = cart_costs["tax"] + shipping_costs["tax"] + payment_costs["tax"]
order = Order.objects.create(
user = user,
session = request.session.session_key,
price = price,
tax = tax,
customer_firstname = invoice_address.firstname,
customer_lastname = invoice_address.lastname,
customer_email = customer_email,
shipping_method = shipping_method,
shipping_price = shipping_costs["price"],
shipping_tax = shipping_costs["tax"],
payment_method = payment_method,
payment_price = payment_costs["price"],
payment_tax = payment_costs["tax"],
invoice_firstname = invoice_address.firstname,
invoice_lastname = invoice_address.lastname,
invoice_company_name = invoice_address.company_name,
invoice_street = invoice_address.street,
invoice_zip_code = invoice_address.zip_code,
invoice_city = invoice_address.city,
invoice_country = invoice_address.country,
invoice_phone = invoice_address.phone,
shipping_firstname = shipping_address.firstname,
shipping_lastname = shipping_address.lastname,
shipping_company_name = shipping_address.company_name,
shipping_street = shipping_address.street,
shipping_zip_code = shipping_address.zip_code,
shipping_city = shipping_address.city,
shipping_country = shipping_address.country,
shipping_phone = shipping_address.phone,
message = request.POST.get("message", ""),
)
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.cartitem_set.all():
OrderItem.objects.create(
order=order,
price_net = cart_item.get_price_net(),
price_gross = cart_item.get_price_gross(),
tax = cart_item.get_tax(),
product = cart_item.product,
product_sku = cart_item.product.sku,
product_name = cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net = cart_item.product.get_price_net(),
product_price_gross = cart_item.product.get_price_gross(),
product_tax = cart_item.product.get_tax(),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
cart.delete()
order_submitted.send(order)
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
return order
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
not_required_address = getattr(settings,
'LFS_CHECKOUT_NOT_REQUIRED_ADDRESS',
'shipping')
invoice_address = customer.selected_invoice_address
shipping_address = customer.selected_shipping_address
if not_required_address == 'shipping':
if request.POST.get("no_shipping"):
shipping_address = customer.selected_invoice_address
else:
shipping_address = customer.selected_shipping_address
else:
if request.POST.get("no_invoice"):
invoice_address = customer.selected_shipping_address
else:
invoice_address = customer.selected_invoice_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request,
shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = customer.selected_invoice_address.email
# Calculate the totals
price = cart.get_price_gross(
request) + shipping_costs["price_gross"] + payment_costs["price"]
tax = cart.get_tax(request) + shipping_costs["tax"] + payment_costs["tax"]
# get voucher data (if voucher exists)
voucher_data = get_voucher_data(request, cart)
# get discounts data
discounts_data = lfs.discounts.utils.get_discounts_data(request)
# calculate total value of discounts and voucher that sum up
summed_up_value = discounts_data['summed_up_value']
if voucher_data['sums_up']:
summed_up_value += voucher_data['voucher_value']
# initialize discounts with summed up discounts
use_voucher = voucher_data['voucher'] is not None
discounts = discounts_data['summed_up_discounts']
if voucher_data['voucher_value'] > summed_up_value or discounts_data[
'max_value'] > summed_up_value:
# use not summed up value
if voucher_data['voucher_value'] > discounts_data['max_value']:
# use voucher only
discounts = []
else:
# use discount only
discounts = discounts_data['max_discounts']
use_voucher = False
for discount in discounts:
price -= discount["price_gross"]
tax -= discount["tax"]
if use_voucher:
price -= voucher_data['voucher_value']
tax -= voucher_data['voucher_tax']
if price < 0:
price = 0
if tax < 0:
tax = 0
# Copy addresses
invoice_address = deepcopy(invoice_address)
invoice_address.id = None
invoice_address.pk = None
invoice_address.save()
shipping_address = deepcopy(shipping_address)
shipping_address.id = None
shipping_address.pk = None
shipping_address.save()
order = Order.objects.create(
user=user,
session=request.session.session_key,
price=price,
tax=tax,
customer_firstname=customer.selected_invoice_address.firstname,
customer_lastname=customer.selected_invoice_address.lastname,
customer_email=customer_email,
shipping_method=shipping_method,
shipping_price=shipping_costs["price_gross"],
shipping_tax=shipping_costs["tax"],
payment_method=payment_method,
payment_price=payment_costs["price"],
payment_tax=payment_costs["tax"],
invoice_address=invoice_address,
shipping_address=shipping_address,
message=request.POST.get("message", ""),
)
delivery_time = cart.get_delivery_time(request)
if delivery_time:
OrderDeliveryTime.objects.create(order=order,
min=delivery_time.min,
max=delivery_time.max,
unit=delivery_time.unit)
invoice_address.order = order
invoice_address.save()
shipping_address.order = order
shipping_address.save()
requested_delivery_date = request.POST.get("requested_delivery_date", None)
if requested_delivery_date is not None:
order.requested_delivery_date = requested_delivery_date
order.save()
if use_voucher:
voucher_data['voucher'].mark_as_used()
order.voucher_number = voucher_data['voucher_number']
order.voucher_price = voucher_data['voucher_value']
order.voucher_tax = voucher_data['voucher_tax']
order.save()
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.get_items():
if cart_item.amount == 0:
continue
order_item = OrderItem.objects.create(
order=order,
price_net=cart_item.get_price_net(request),
price_gross=cart_item.get_price_gross(request),
tax=cart_item.get_tax(request),
product=cart_item.product,
product_sku=cart_item.product.sku,
product_name=cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net=cart_item.product.get_price_net(request),
product_price_gross=cart_item.get_product_price_gross(request),
product_tax=cart_item.product.get_tax(request),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
# Copy properties to order
if cart_item.product.is_configurable_product():
for cpv in cart_item.properties.all():
OrderItemPropertyValue.objects.create(order_item=order_item,
property=cpv.property,
value=cpv.value)
for discount in discounts:
OrderItem.objects.create(
order=order,
price_net=-discount["price_net"],
price_gross=-discount["price_gross"],
tax=-discount["tax"],
product_sku=discount["sku"],
product_name=discount["name"],
product_amount=1,
product_price_net=-discount["price_net"],
product_price_gross=-discount["price_gross"],
product_tax=-discount["tax"],
)
# Re-initialize selected addresses to be equal to default addresses for next order
customer.sync_default_to_selected_addresses()
customer.save()
# Send signal before cart is deleted.
order_created.send(order, cart=cart, request=request)
cart.delete()
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
ong = import_symbol(settings.LFS_ORDER_NUMBER_GENERATOR)
try:
order_numbers = ong.objects.get(id="order_number")
except ong.DoesNotExist:
order_numbers = ong.objects.create(id="order_number")
try:
order_numbers.init(request, order)
except AttributeError:
pass
order.number = order_numbers.get_next()
order.save()
return order
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
invoice_address = customer.selected_invoice_address
if customer.selected_shipping_address:
shipping_address = customer.selected_shipping_address
else:
shipping_address = customer.selected_invoice_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request, shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = customer.selected_invoice_address.email
# Calculate the totals
price = cart.get_price_gross(request) + shipping_costs["price"] + payment_costs["price"]
tax = cart.get_tax(request) + shipping_costs["tax"] + payment_costs["tax"]
# Discounts
discounts = lfs.discounts.utils.get_valid_discounts(request)
for discount in discounts:
price = price - discount["price"]
tax = tax - discount["tax"]
# Add voucher if one exists
try:
voucher_number = lfs.voucher.utils.get_current_voucher_number(request)
voucher = Voucher.objects.get(number=voucher_number)
except Voucher.DoesNotExist:
voucher = None
else:
is_voucher_effective, voucher_message = voucher.is_effective(cart)
if is_voucher_effective:
voucher_number = voucher.number
voucher_price = voucher.get_price_gross(cart)
voucher_tax = voucher.get_tax(cart)
price -= voucher_price
tax -= voucher_tax
else:
voucher = None
order = Order.objects.create(
user=user,
session=request.session.session_key,
price=price,
tax=tax,
customer_firstname=customer.selected_invoice_address.firstname,
customer_lastname=customer.selected_invoice_address.lastname,
customer_email=customer_email,
shipping_method=shipping_method,
shipping_price=shipping_costs["price"],
shipping_tax=shipping_costs["tax"],
payment_method=payment_method,
payment_price=payment_costs["price"],
payment_tax=payment_costs["tax"],
invoice_firstname=customer.selected_invoice_address.firstname,
invoice_lastname=customer.selected_invoice_address.lastname,
invoice_line1=invoice_address.company_name,
invoice_line2=invoice_address.street,
invoice_city=invoice_address.city,
invoice_state=invoice_address.state,
invoice_code=invoice_address.zip_code,
invoice_country=Country.objects.get(code=invoice_address.country.code),
invoice_phone=customer.selected_invoice_address.phone,
shipping_firstname=shipping_address.firstname,
shipping_lastname=shipping_address.lastname,
shipping_line1=shipping_address.company_name,
shipping_line2=shipping_address.street,
shipping_city=shipping_address.city,
shipping_state=shipping_address.state,
shipping_code=shipping_address.zip_code,
shipping_country=Country.objects.get(code=shipping_address.country.code),
shipping_phone=shipping_address.phone,
message=request.POST.get("message", ""),
)
requested_delivery_date = request.POST.get("requested_delivery_date", None)
if requested_delivery_date is not None:
order.requested_delivery_date = requested_delivery_date
order.save()
if voucher:
voucher.mark_as_used()
order.voucher_number = voucher_number
order.voucher_price = voucher_price
order.voucher_tax = voucher_tax
order.save()
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.cartitem_set.all():
order_item = OrderItem.objects.create(
order=order,
price_net=cart_item.get_price_net(request),
price_gross=cart_item.get_price_gross(request),
tax=cart_item.get_tax(request),
product=cart_item.product,
product_sku=cart_item.product.sku,
product_name=cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net=cart_item.product.get_price_net(request),
product_price_gross=cart_item.get_product_price_gross(request),
product_tax=cart_item.product.get_tax(request),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
# Copy properties to order
if cart_item.product.is_configurable_product():
for cpv in cart_item.properties.all():
OrderItemPropertyValue.objects.create(
order_item=order_item, property=cpv.property, value=cpv.value)
for discount in discounts:
OrderItem.objects.create(
order=order,
price_net=-(discount["price"] - discount["tax"]),
price_gross=-discount["price"],
tax=-discount["tax"],
product_sku=discount["sku"],
product_name=discount["name"],
product_amount=1,
product_price_net=-(discount["price"] - discount["tax"]),
product_price_gross=-discount["price"],
product_tax=-discount["tax"],
)
cart.delete()
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
try:
order_numbers = MODELS.OrderNumberGenerator.objects.get(id="order_number")
except MODELS.OrderNumberGenerator.DoesNotExist:
order_numbers = MODELS.OrderNumberGenerator.objects.create(id="order_number")
try:
order_numbers.init(request, order)
except AttributeError:
pass
order.number = order_numbers.get_next()
order.save()
return order
def add_order(request):
"""Adds an order based on current cart for the current customer.
It assumes that the customer is prepared with all needed information. This
is within the responsibility of the checkout form.
"""
customer = customer_utils.get_customer(request)
order = None
invoice_address = customer.selected_invoice_address
if customer.selected_shipping_address:
shipping_address = customer.selected_shipping_address
else:
shipping_address = customer.selected_invoice_address
cart = cart_utils.get_cart(request)
if cart is None:
return order
cart_costs = cart_utils.get_cart_costs(request, cart, total=False)
shipping_method = shipping_utils.get_selected_shipping_method(request)
shipping_costs = shipping_utils.get_shipping_costs(request,
shipping_method)
payment_method = payment_utils.get_selected_payment_method(request)
payment_costs = payment_utils.get_payment_costs(request, payment_method)
# Set email dependend on login state. An anonymous customer doesn't have a
# django user account, so we set the name of the invoice address to the
# customer name.
# Note: After this has been processed the order's customer email has an
# email in any case. That means you can use it to send emails to the
# customer.
if request.user.is_authenticated():
user = request.user
customer_email = user.email
else:
user = None
customer_email = invoice_address.email
# Calculate the totals
price = cart_costs["price"] + shipping_costs["price"] + payment_costs[
"price"]
tax = cart_costs["tax"] + shipping_costs["tax"] + payment_costs["tax"]
order = Order.objects.create(
user=user,
session=request.session.session_key,
price=price,
tax=tax,
customer_firstname=invoice_address.firstname,
customer_lastname=invoice_address.lastname,
customer_email=customer_email,
shipping_method=shipping_method,
shipping_price=shipping_costs["price"],
shipping_tax=shipping_costs["tax"],
payment_method=payment_method,
payment_price=payment_costs["price"],
payment_tax=payment_costs["tax"],
invoice_firstname=invoice_address.firstname,
invoice_lastname=invoice_address.lastname,
invoice_company_name=invoice_address.company_name,
invoice_street=invoice_address.street,
invoice_zip_code=invoice_address.zip_code,
invoice_city=invoice_address.city,
invoice_country=invoice_address.country,
invoice_phone=invoice_address.phone,
shipping_firstname=shipping_address.firstname,
shipping_lastname=shipping_address.lastname,
shipping_company_name=shipping_address.company_name,
shipping_street=shipping_address.street,
shipping_zip_code=shipping_address.zip_code,
shipping_city=shipping_address.city,
shipping_country=shipping_address.country,
shipping_phone=shipping_address.phone,
message=request.POST.get("message", ""),
)
# Copy bank account if one exists
if customer.selected_bank_account:
bank_account = customer.selected_bank_account
order.account_number = bank_account.account_number
order.bank_identification_code = bank_account.bank_identification_code
order.bank_name = bank_account.bank_name
order.depositor = bank_account.depositor
order.save()
# Copy cart items
for cart_item in cart.cartitem_set.all():
OrderItem.objects.create(
order=order,
price_net=cart_item.get_price_net(),
price_gross=cart_item.get_price_gross(),
tax=cart_item.get_tax(),
product=cart_item.product,
product_sku=cart_item.product.sku,
product_name=cart_item.product.get_name(),
product_amount=cart_item.amount,
product_price_net=cart_item.product.get_price_net(),
product_price_gross=cart_item.product.get_price_gross(),
product_tax=cart_item.product.get_tax(),
)
cart_item.product.decrease_stock_amount(cart_item.amount)
cart.delete()
order_submitted.send(order)
# Note: Save order for later use in thank you page. The order will be
# removed from the session if the thank you page has been called.
request.session["order"] = order
return order
