def get_basket_html(request, basket):
"""
Return the basket (html).
"""
if basket.prefix not in settings.SHOP_BASKET_ALLOWED_PREFIX and request.user and (
request.user.is_staff or request.user.is_superuser):
template_name = 'cubane/ishop/elements/order/basket/basket.html'
else:
template_name = 'cubane/ishop/elements/basket/basket_panel.html'
template = get_template(template_name)
template_context = {
'settings':
request.settings,
'basket':
basket,
'post_url':
reverse('shop.basket.update') + '?r=%s' % get_return_url(request)
}
# allow for the template context to be updated before rendering the basket
shop = get_shop()
template_context = shop.on_basket_context(request, basket,
template_context)
return template.render(template_context, request)
def basket_editor_add_to_basket(self, request):
from cubane.ishop.views import get_shop
pk = request.POST.get('pk')
prefix = request.POST.get('prefix')
shop = get_shop()
product = shop.get_products().get(pk=pk)
return {'product': product, 'prefix': prefix, 'settings': settings}
def get_payment_gateway_by_identifier(identifier):
# parse payment gateway identifier (int)
try:
identifier = int(identifier)
except ValueError:
raise Http404('Invalid payment gateway identifier \'%s\'.' %
identifier)
# get payment gateway by identifier
from cubane.ishop.views import get_shop
shop = get_shop()
return shop.get_payment_gateway_by_identifier(identifier)
def render(self, name, value, attrs=None, renderer=None):
if value is None: value = ''
# get shop
from cubane.ishop.views import get_shop
shop = get_shop()
# class
_class = attrs.get('class', '')
_class += ' product-variety'
if len(self._assignments) == 1:
_class += ' single-option'
if self._variety.sku:
_class += ' sku'
_class = _class.strip()
attrs['class'] = _class
# variety svg layer identifier
if self._variety.layer:
attrs['data-layer'] = self._variety.layer
final_attrs = build_attrs(self.attrs, attrs, name=name)
output = []
if self._appended_content:
output.append('<div class="input-append">')
if self._variety.style == Variety.STYLE_SELECT:
output.append('<select%s>' % flatatt(final_attrs))
options = self.render_options(shop, self._assignments, [value])
if options: output.append(options)
output.append('</select>')
else:
with_image = self._variety.style == Variety.STYLE_LIST_WITH_IMAGE
attrs['class'] += ' select-list' + (
' select-list-image' if with_image else ' select-list-plain')
final_attrs = build_attrs(self.attrs, attrs, name=name)
output.append('<div%s">' % flatatt(final_attrs))
options = self.render_list_options(shop, self._assignments,
[value], with_image)
if options: output.append(options)
output.append('<input type="hidden" name="%s" value="%s">' %
(final_attrs.get('name'), escape(value)))
output.append('</div>')
if self._appended_content:
output.append('<span class="add-on">' + self._appended_content +
'</span>')
output.append('</div>')
return mark_safe(u'\n'.join(output))
def basket_editor_search(self, request):
from cubane.ishop.views import get_shop
q = request.POST.get('q')
shop = get_shop()
products = shop.get_products().filter(
Q(title__icontains=q) | Q(barcode__startswith=q)
| Q(part_number__startswith=q)
| Q(sku_enabled=True, sku__startswith=q),
draft=False)
return {'products': products[:100]}
def product(request, slug, pk):
"""
Present single product and description and allow customers to add
the product to their basket.
"""
shop = get_shop()
# get product
product = shop.get_product_or_404(pk, slug)
if isinstance(product, HttpResponse):
return product
return shop.product_page(request, product)
def category(request, slug, pk):
"""
Present a list of products for the given category and allow customers
to drill down by filtering by varieties.
"""
shop = get_shop()
# current category based on slug url and pk
category = shop.get_category_or_404(pk, slug)
if isinstance(category, HttpResponse):
return category
return shop.category_page(request, category)
def before_save(self, request, cleaned_data, instance, edit):
# default values
if not edit:
from cubane.ishop.views import get_shop
shop = get_shop()
instance.customer_not_present = True
instance.payment_gateway = shop.get_default_payment_gateway()
# save basket.
basket = Basket(request, prefix=instance.backend_basket_prefix)
if not basket.is_empty():
instance.save_basket(basket)
# change status
if request.POST.get('next-status'):
cleaned_data['status'] = int(request.POST.get('next-status'))
def handle_payment_response(request, identifier):
"""
Handle the response from a specific payment gateway specified by the
given identifier.
"""
# parse payment gateway identifier (int)
try:
identifier = int(identifier)
except ValueError:
raise Http404('Invalid payment gateway identifier \'%s\'.' %
identifier)
# get payment gateway by identifier
from cubane.ishop.views import get_shop
shop = get_shop()
gateway = shop.get_payment_gateway_by_identifier(identifier)
# let the payment gateway figure out the correct transaction id that applies
transaction_id = gateway.get_transaction_id(request)
# process payment
return process_payment(request, gateway, transaction_id)
def delivery_address(request, pk=None):
"""
Delivery Address Page.
"""
shop = get_shop()
return shop.account_delivery_address(request, pk)
def billing(request):
"""
Billing Page.
"""
shop = get_shop()
return shop.account_billing(request)
def delivery(request):
"""
Delivery Page.
"""
shop = get_shop()
return shop.account_delivery(request)
def orders(request, status):
"""
Order Page.
"""
shop = get_shop()
return shop.account_orders(request, status)
def details(request):
"""
Details Page.
"""
shop = get_shop()
return shop.account_details(request)
def test_get_shop_should_raise_if_not_configured(self):
shop_views.SHOP_CLASS=None
with self.assertRaises(ValueError):
get_shop()
def login(request):
"""
Login Page.
"""
shop = get_shop()
return shop.account_login(request)
def logout(request):
"""
Logout.
"""
shop = get_shop()
return shop.account_logout(request)
def index(request):
"""
Index Page.
"""
shop = get_shop()
return shop.account_index(request)
def search(request):
"""
Search Result Page.
"""
shop = get_shop()
return shop.search_page(request)
def add(request):
"""
Add given product to the customer's basket and redirect to the basket page.
"""
product = get_product_or_404(request)
return_url = get_return_url(request)
form = AddToBasketForm(request.POST, request=request, product=product)
variant = ''
quantity = 0
price = 0
prefix = None
if form.is_valid():
d = form.cleaned_data
variety_options = form.get_variety_options()
variety_option_labels = form.get_variety_option_labels(variety_options)
variant = ', '.join([option.title for option in variety_options])
quantity = form.get_quantity()
prefix = get_basket_prefix(request, d)
# add to basket
basket = Basket(request, prefix=prefix)
item = basket.add_item(product,
variety_options,
quantity,
custom=None,
labels=variety_option_labels)
if item:
price = item.total_product
else:
messages.error(
request,
"Please note that the product '%s' cannot be added to basket."
% product.title)
# alert for non-returnable products
if product.non_returnable:
messages.warning(
request,
"Please note that the product '%s' cannot be returned." %
product.title)
# hook
shop = get_shop()
shop.on_basket_added(request, basket, product, variety_options,
quantity)
basket.save()
errors = False
else:
errors = form.errors
if request.is_ajax():
basket = Basket(request, prefix=prefix)
return to_json_response({
'success':
True,
'html':
get_basket_html(request, basket),
'errors':
errors,
'prefix':
basket.prefix,
'added':
product.to_ga_dict({
'variant': variant,
'quantity': quantity,
'price': price
})
})
else:
return HttpResponseRedirect(return_url)
def test_get_shop_should_return_shop_class_instance(self):
shop = get_shop()
self.assertIsInstance(shop, self.testapp_shop_class)
def login(request):
"""
Provide ability to choose to login with an existing account, create a new
account or just providing an email address for a guest checkout.
"""
basket = Basket(request)
if basket.is_empty():
return HttpResponseRedirect('/')
login_form = CustomerLoginForm(request=request, prefix='customer')
guest_form = GuestLoginForm(prefix='guest')
form = None
if request.method == 'POST':
if request.POST.get('password_forgotten', None) != None:
login_form = PasswordForgottenForm(request.POST, prefix='customer')
form = login_form
elif request.POST.get('customer', None) != None:
login_form = CustomerLoginForm(request.POST,
request=request,
prefix='customer')
form = login_form
else:
guest_form = GuestLoginForm(request.POST, prefix='guest')
form = guest_form
if form != None and form.is_valid():
if isinstance(form, PasswordForgottenForm):
email = form.cleaned_data.get('email')
if request.context.password_forgotten(request, email):
messages.success(
request, 'Your new password has been send to: %s.' % email)
else:
messages.error(
request,
'We were not able to send an email to: %s' % email)
return HttpResponseRedirect(reverse('shop.order.login'))
elif isinstance(form, CustomerLoginForm):
user = form.get_user()
if user.is_authenticated():
auth_login(request, user)
request.session[settings.GUEST_USER_SESSION_VAR] = ''
response = HttpResponseRedirect(reverse('shop.order.delivery'))
response.set_cookie('cubaneShopLogin', '1')
# hook
shop = get_shop()
shop.on_customer_login(request, basket, user)
return response
else:
if request.user.is_authenticated():
auth_logout(request)
# hook
shop = get_shop()
shop.on_customer_logout(request, basket)
basket.save()
request.session[
settings.GUEST_USER_SESSION_VAR] = form.cleaned_data.get(
'email')
return HttpResponseRedirect(reverse('shop.order.delivery'))
return {
'login_form': login_form,
'guest_form': guest_form,
'basket': basket
}
def test_get_shop_should_raise_if_class_does_not_exist(self):
shop_views.SHOP_CLASS=None
with self.assertRaises(ImportError):
get_shop()
def delete_delivery_address(request, pk):
"""
Delete Delivery Address.
"""
shop = get_shop()
return shop.account_delete_delivery_address(request, pk)
def signup(request):
"""
Signup Page.
"""
shop = get_shop()
return shop.account_signup(request)
def password(request):
"""
Password Page.
"""
shop = get_shop()
return shop.account_password(request)
def test_get_shop_should_return_new_instances_every_time(self):
shop = get_shop()
self.assertNotEqual(shop, get_shop())
