def test_request_with_user_returns_last_order(self):
setattr(self.request, 'user', self.user)
order1 = Order.objects.create(user=self.user)
ret = get_order_from_request(self.request)
self.assertEqual(ret, order1)
order2 = Order.objects.create(user=self.user)
ret = get_order_from_request(self.request)
self.assertEqual(ret, order2)
def test_request_with_user_returns_last_order(self):
setattr(self.request, 'user', self.user)
order1 = Order.objects.create(user=self.user)
ret = get_order_from_request(self.request)
self.assertEqual(ret, order1)
order2 = Order.objects.create(user=self.user)
ret = get_order_from_request(self.request)
self.assertEqual(ret, order2)
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# Set the order status:
order = get_order_from_request(self.request)
if order:
order.status = Order.COMPLETED
order.save()
else:
order = Order.objects.get_latest_for_user(self.request.user)
#TODO: Is this ever the case?
ctx.update({
'order': order,
})
# TODO: move away from shop!!
# ctx.update({'downloads': [1], })
completed.send(sender=self, order=order)
# Empty the customers basket, to reflect that the purchase was
# completed
cart_object = get_or_create_cart(self.request)
cart_object.empty()
return ctx
def get_context_data(self, **kwargs):
ctx = super(MyOrderConfirmView, self).get_context_data(**kwargs)
order = get_order_from_request(self.request)
ctx.update({
'order': order,
})
return ctx
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# Set the order status:
order = get_order_from_request(self.request)
if order:
order.status = Order.COMPLETED
order.save()
else:
order = Order.objects.get_latest_for_user(self.request.user)
#TODO: Is this ever the case?
ctx.update({'order': order, })
# TODO: move away from shop!!
# ctx.update({'downloads': [1], })
completed.send(sender=self, order=order)
# Empty the customers basket, to reflect that the purchase was
# completed
cart_object = get_or_create_cart(self.request)
cart_object.empty()
return ctx
def test_03_request_with_order_returns_order(self):
self.create_fixtures()
session = {}
session['order_id'] = self.order.id
setattr(self.request, 'session', session)
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
def get_context_data(self, **kwargs):
ctx = super(MyOrderConfirmView, self).get_context_data(**kwargs)
order = get_order_from_request(self.request)
ctx.update({
'order': order,
})
return ctx
def test_04_request_with_user_returns_correct_order(self):
self.create_fixtures()
setattr(self.request, 'user', self.user)
self.order.user = self.user
self.order.save()
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
def entry_view(request, *args, **kwargs):
"""Call card's provider API with correct price and payment description."""
order = get_order_from_request(request)
amount = order.get_total()
return HttpResponseRedirect(
'https://visa.com/payment',
data={'key': 'my_secret_key',
'amount': amount})
def entry_view(self, request):
"""
Calls VISA/MASTERCARD API with correct price
and payment description
"""
order = get_order_from_request(request)
amount = order.get_total()
return HttpResponseRedirect("https://visa.com/payment", data={"key": "my_secret_key", "amount": amount})
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# put the latest order in the context only if it is completed
order = get_order_from_request(self.request)
if order and order.status == Order.COMPLETED:
ctx.update({'order': order, })
return ctx
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# put the latest order in the context only if it is completed
order = get_order_from_request(self.request)
if order and order.status == Order.COMPLETED:
ctx.update({'order': order, })
return ctx
def test_addresses_are_conserved_properly(self):
session = {}
session['order_id'] = self.order.pk
setattr(self.request, 'session', session)
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
self.assertEqual(ret.shipping_address_text,
self.order.shipping_address_text)
self.assertEqual(ret.billing_address_text,
self.order.billing_address_text)
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# Set the order status:
order = get_order_from_request(self.request)
order.status = Order.COMPLETED
order.save()
completed.send(sender=self, order=order)
return ctx
def test_addresses_are_conserved_properly(self):
session = {}
session['order_id'] = self.order.id
setattr(self.request, 'session', session)
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
self.assertEqual(ret.shipping_address_text,
self.order.shipping_address_text)
self.assertEqual(ret.billing_address_text,
self.order.billing_address_text)
def get_order(self, request):
'''
Returns the order object for the current shopper.
This is called from the backend's views as:
>>> order = self.shop.getOrder(request)
'''
# it might seem a bit strange to simply forward the call to a helper,
# but this avoids exposing the shop's internal workings to module
# writers
return get_order_from_request(request)
def get_order(self, request):
"""
Returns the order object for the current shopper.
This is called from the backend's views as:
>>> order = self.shop.getOrder(request)
"""
# it might seem a bit strange to simply forward the call to a helper,
# but this avoids exposing the shop's internal workings to module
# writers
return get_order_from_request(request)
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# put the latest order in the context only if it is completed
order = get_order_from_request(self.request)
if order and order.status == Order.COMPLETED:
ctx.update({'order': order, })
# Empty the customers basket, to reflect that the purchase was
# completed
cart_object = get_or_create_cart(self.request)
cart_object.empty()
return ctx
def callback_view(request, *args, **kwargs):
"""Receive callback from credit card payment service and complete the order."""
order = get_order_from_request(request)
OrderPayment.objects.create(
order=order,
amount=request.POST["amount"],
transaction_id=request.POST["id"],
payment_method=PaymentBackend.objects.get(url_name="credit_card"))
order.mark_as_completed()
clean_cart(request)
return HttpResponseRedirect(reverse("home"))
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# Set the order status:
order = get_order_from_request(self.request)
order.status = Order.COMPLETED
order.save()
completed.send(sender=self, order=order)
# Empty the customers basket, to reflect that the purchase was completed
cart_object = get_or_create_cart(self.request)
cart_object.empty()
return ctx
def pay_on_delivery(request):
"""
This simple PaymentBackend has only one view - entry point which does some work
internally and then redirects to the "successful URL".
More complicated views should have entry point (where it calls external API)
and a callback view which will be called by the API with result.
"""
# Get the order object
order = get_order_from_request(request)
# Since we don't know if the money will be really collected mark the order
# just as CONFIRMED instead of COMPLETED.
order.mark_as_confirmed()
clean_cart(request)
return HttpResponseRedirect(reverse("home"))
def get_context_data(self, **kwargs):
ctx = super(ShopTemplateView, self).get_context_data(**kwargs)
# put the latest order in the context only if it is completed
order = get_order_from_request(self.request)
if order and order.status == Order.COMPLETED:
ctx.update({
'order': order,
})
# Empty the customers basket, to reflect that the purchase was
# completed
cart_object = get_or_create_cart(self.request)
cart_object.empty()
return ctx
def view_display_fees(self, request):
"""
A simple, normal view that displays a template showing how much the
shipping will be (it's an example, alright)
"""
ctx = {}
#ctx = super(ShippingDHL, self).get_context_data(**kwargs)
order = get_order_from_request(request)
cart = get_cart_from_session(request)
ctx.update({'shipping_costs': self.get_shipping_cost(cart),
#'shipping_costs': Decimal(self.rate),
'order': order,
'cart': cart,
})
return render_to_response('shop/shipping/flat_rate/display_fees.html',
ctx, context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
"""
This overrides the context from the normal template view
"""
ctx = super(SelectPaymentView, self).get_context_data(**kwargs)
# Set the order status:
order = get_order_from_request(self.request)
order.status = Order.PAYMENT
payment_selection.send(sender=self, order=order)
payment_modules_list = backends_pool.get_payment_backends_list()
select = {}
for backend in payment_modules_list:
url = reverse(backend.url_namespace)
select.update({backend.backend_name: url})
ctx.update({"payment_options": select})
return ctx
def test_request_without_user_or_session_returns_none(self):
ret = get_order_from_request(self.request)
self.assertEqual(ret, None)
def test_01_request_without_user_or_session_returns_none(self):
self.create_fixtures()
ret = get_order_from_request(self.request)
self.assertEqual(ret, None)
def test_02_request_with_session_without_order_returns_none(self):
self.create_fixtures()
setattr(self.request,'session', {})
ret = get_order_from_request(self.request)
self.assertEqual(ret, None)
def test_request_with_order_returns_order(self):
session = {}
session["order_id"] = self.order.id
setattr(self.request, "session", session)
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
def test_request_with_session_without_order_returns_none(self):
setattr(self.request, "session", {})
ret = get_order_from_request(self.request)
self.assertEqual(ret, None)
def test_request_without_user_or_session_returns_none(self):
ret = get_order_from_request(self.request)
self.assertEqual(ret, None)
def test_request_with_order_returns_order(self):
session = {}
session['order_id'] = self.order.pk
setattr(self.request, 'session', session)
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
def inner(request, *args, **kwargs):
if get_order_from_request(request) is None:
return HttpResponseRedirect(redirect_url)
return func(request, *args, **kwargs)
def test_request_with_user_returns_correct_order(self):
setattr(self.request, "user", self.user)
self.order.user = self.user
self.order.save()
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
def inner(request, *args, **kwargs):
order = get_order_from_request(request)
if order is None or getattr(order, 'status',
Order.COMPLETED) >= Order.COMPLETED:
return HttpResponseRedirect(redirect_url)
return func(request, *args, **kwargs)
def confirm_order(self):
order = get_order_from_request(self.request)
order.status = Order.CONFIRMED
order.save()
def get_redirect_url(self, **kwargs):
"""Redirect to the payment selected for the order."""
order = get_order_from_request(self.request)
self.url = reverse(order.payment_backend.url_name)
return super(OrderConfirmView, self).get_redirect_url(**kwargs)
def inner(request, *args, **kwargs):
order = get_order_from_request(request)
if order is None or getattr(order, 'status', Order.COMPLETED) >= Order.COMPLETED:
return HttpResponseRedirect(reverse(url_name))
return func(request, *args, **kwargs)
def test_request_with_order_returns_order(self):
session = {}
session['order_id'] = self.order.pk
setattr(self.request, 'session', session)
ret = get_order_from_request(self.request)
self.assertEqual(ret, self.order)
