def shipping_cost(request):
""" Returns the shipping cost for a given country
If the shipping cost for the given country has not been set, it will
fallback to the default shipping cost if it has been enabled in the app
settings
"""
status_code = status.HTTP_400_BAD_REQUEST
try:
kwargs = get_shipping_cost_kwargs(request)
except (utils.InvalidShippingCountry,
utils.InvalidShippingDestination) as e:
data = {'message': e.message}
else:
try:
data = utils.get_shipping_cost(**kwargs)
except utils.InvalidShippingRate:
data = {
"message":
"Shipping option {} is invalid".format(kwargs['name'])
}
except utils.InvalidShippingCountry:
data = {
"message":
"Shipping to {} is not available".format(
kwargs['country_code'])
}
else:
status_code = status.HTTP_200_OK
return Response(data=data, status=status_code)
def shipping_cost(request):
""" Returns the shipping cost for a given country
If the shipping cost for the given country has not been set, it will
fallback to the default shipping cost if it has been enabled in the app
settings
"""
try:
code = request.query_params.get('country_code')
except AttributeError:
return Response(data={"message": "No country code supplied"},
status=status.HTTP_400_BAD_REQUEST)
option = request.query_params.get('shipping_rate_name', 'standard')
try:
settings = Configuration.for_site(request.site)
data = utils.get_shipping_cost(settings, code, option)
response = Response(data=data, status=status.HTTP_200_OK)
except utils.InvalidShippingRate:
response = Response(
data={"message": "Shipping option {} is invalid".format(option)},
status=status.HTTP_400_BAD_REQUEST)
except utils.InvalidShippingCountry:
response = Response(
data={"message": "Shipping to {} is not available".format(code)},
status=status.HTTP_400_BAD_REQUEST)
return response
def shipping_rate(context, **kwargs):
"""Return the shipping rate for a country & shipping option name.
"""
settings = Configuration.for_site(context["request"].site)
code = kwargs.get('code', None)
name = kwargs.get('name', None)
return get_shipping_cost(settings, code, name)
def test_basket_rate(self):
# this tests that we get a basket rate that is just tied to the basket and nothing else
# (i.e. this basket qualifies for free shipping or something like that)
result = get_shipping_cost(Configuration(),
name='98d17c43-7e20-42bd-b603-a4c83c829c5a',
basket_id=self.bid)
self.assertEqual(result["rate"], 99)
self.assertEqual(result["description"],
'313037e1-644a-4570-808a-f9ba82ecfb34')
def test_address_rate(self):
# this tests that we get a rate tied to a particular address
result = get_shipping_cost(
Configuration(),
name='72991859-dc0b-463e-821a-bf8b04aaed2c',
destination=self.address,
)
self.assertEqual(result["rate"], 95)
self.assertEqual(result["description"],
'78b03c47-b20f-4f91-8161-47340367fb34')
def test_basket_address_rate(self):
# this tests that we get a rate tied to a particular basket and a particular address
result = get_shipping_cost(
Configuration(),
name='8e721550-594c-482b-b512-54dc1744dff8',
basket_id=self.bid,
destination=self.address,
)
self.assertEqual(result["rate"], 97)
self.assertEqual(result["description"],
'eacb446d-eb17-4ea7-82c1-ac2f62a53a7d')
def test_default_shipping_cost(self):
ls = Configuration(default_shipping_enabled=True)
result = get_shipping_cost(ls)
self.assertEqual(ls.default_shipping_rate, result["rate"])
def test_multiple_shipping_cost(self):
sr = ShippingRateFactory(countries=[self.country])
sr2 = ShippingRateFactory(countries=[self.country])
result = get_shipping_cost(Configuration(), self.country.pk, sr.name)
self.assertEqual(result["rate"], sr.rate)
def create_order(email,
request,
addresses=None,
shipping_address=None,
billing_address=None,
shipping_option=None,
capture_payment=False):
"""
Create an order from a basket and customer infomation
"""
basket_items, _ = get_basket_items(request)
if addresses:
# Longclaw < 0.2 used 'shipping_name', longclaw > 0.2 uses a consistent
# prefix (shipping_address_xxxx)
try:
shipping_name = addresses['shipping_name']
except KeyError:
shipping_name = addresses['shipping_address_name']
shipping_country = addresses['shipping_address_country']
if not shipping_country:
shipping_country = None
shipping_address, _ = Address.objects.get_or_create(
name=shipping_name,
line_1=addresses['shipping_address_line1'],
city=addresses['shipping_address_city'],
postcode=addresses['shipping_address_zip'],
country=shipping_country)
shipping_address.save()
try:
billing_name = addresses['billing_name']
except KeyError:
billing_name = addresses['billing_address_name']
billing_country = addresses['shipping_address_country']
if not billing_country:
billing_country = None
billing_address, _ = Address.objects.get_or_create(
name=billing_name,
line_1=addresses['billing_address_line1'],
city=addresses['billing_address_city'],
postcode=addresses['billing_address_zip'],
country=billing_country)
billing_address.save()
else:
shipping_country = shipping_address.country
ip_address = get_real_ip(request)
if shipping_country and shipping_option:
site_settings = Configuration.for_site(request.site)
shipping_rate = get_shipping_cost(site_settings,
shipping_address.country.pk,
shipping_option)['rate']
else:
shipping_rate = Decimal(0)
order = Order(email=email,
ip_address=ip_address,
shipping_address=shipping_address,
billing_address=billing_address,
shipping_rate=shipping_rate)
order.save()
# Create the order items & compute total
total = 0
for item in basket_items:
total += item.total()
order_item = OrderItem(product=item.variant,
quantity=item.quantity,
order=order)
order_item.save()
if capture_payment:
desc = 'Payment from {} for order id #{}'.format(email, order.id)
try:
transaction_id = GATEWAY.create_payment(request,
total + shipping_rate,
description=desc)
order.payment_date = timezone.now()
order.transaction_id = transaction_id
# Once the order has been successfully taken, we can empty the basket
destroy_basket(request)
except PaymentError:
order.status = order.FAILURE
order.save()
return order