def post(self, request, *args, **kwargs):
offer = Offer.objects.get(site=get_site_from_request(request),
slug=self.kwargs["slug"])
if request.user.is_anonymous:
request.session['session_cart'] = self.session_cart(request, offer)
else:
profile, created = self.request.user.customer_profile.get_or_create(
site=get_site_from_request(request))
cart = profile.get_cart_or_checkout_cart()
if cart.status == Invoice.InvoiceStatus.CHECKOUT:
cart.status = Invoice.InvoiceStatus.CART
cart.save()
if profile.has_product(
offer.products.all()) and not offer.allow_multiple:
messages.info(self.request,
_("You Have Already Purchased This Item"))
elif cart.order_items.filter(
offer__products__in=offer.products.all()).count(
) and not offer.allow_multiple:
messages.info(
self.request,
_("You already have this product in you cart. You can only buy one"
))
else:
messages.info(self.request, _("Added item to cart."))
cart.add_offer(offer)
return redirect('vendor:cart') # Redirect to cart on success
def get(self, request, *args, **kwargs):
context = super().get_context_data(**kwargs)
clear_session_purchase_data(request)
invoice = get_purchase_invoice(request.user,
get_site_from_request(request))
if not invoice.order_items.count():
return redirect('vendor:cart')
invoice.status = Invoice.InvoiceStatus.CHECKOUT
invoice.save()
existing_account_address = Address.objects.filter(
profile__user=request.user,
profile__site=get_site_from_request(request))
if existing_account_address:
# TODO: In future the user will be able to select from multiple saved address
form = AccountInformationForm(
initial={'email': request.user.email},
instance=existing_account_address[0])
else:
form = AccountInformationForm(
initial={
'first_name': request.user.first_name,
'last_name': request.user.last_name,
'email': request.user.email
})
context['form'] = form
context['invoice'] = invoice
return render(request, self.template_name, context)
def post(self, request, *args, **kwargs):
offer = Offer.objects.get(site=get_site_from_request(request),
slug=self.kwargs["slug"])
if request.user.is_anonymous:
offer_key = str(offer.pk)
session_cart = get_or_create_session_cart(request.session)
if offer_key in session_cart:
session_cart[offer_key]['quantity'] -= 1
if session_cart[offer_key]['quantity'] <= 0:
del (session_cart[offer_key])
request.session['session_cart'] = session_cart
else:
profile = self.request.user.customer_profile.get(
site=get_site_from_request(
request)) # Make sure they have a cart
cart = profile.get_cart_or_checkout_cart()
if cart.status == Invoice.InvoiceStatus.CHECKOUT:
cart.status = Invoice.InvoiceStatus.CART
cart.save()
cart.remove_offer(offer)
messages.info(self.request, _("Removed item from cart."))
return redirect('vendor:cart') # Redirect to cart on success
def get(self, request, *args, **kwargs):
context = super().get_context_data(**kwargs)
if request.user.is_anonymous:
session_cart = get_or_create_session_cart(request.session)
context['invoice'] = {}
if len(session_cart):
context['order_items'] = [
OrderItem(offer=Offer.objects.get(pk=offer),
quantity=session_cart[offer]['quantity'])
for offer in session_cart.keys()
]
else:
context['order_items'] = []
context['invoice']['subtotal'] = sum(
[item.total for item in context['order_items']])
context['invoice']['shipping'] = 0
context['invoice']['tax'] = 0
context['invoice']['total'] = context['invoice']['subtotal']
return render(request, self.template_name, context)
profile, created = self.request.user.customer_profile.get_or_create(
site=get_site_from_request(request))
cart = profile.get_cart_or_checkout_cart()
context['invoice'] = cart
context['order_items'] = [
order_item for order_item in cart.order_items.all()
]
return render(request, self.template_name, context)
def get_product_queryset(self):
"""
Method to get the Product(s) needed for the check. Can be overridden to handle complex queries.
"""
return self.model.objects.filter(
site=get_site_from_request(self.request),
slug=self.kwargs['slug']).get().products.all()
def post(self, request, *args, **kwargs):
context = super().get_context_data(**kwargs)
invoice = get_purchase_invoice(request.user,
get_site_from_request(request))
if not invoice.order_items.count(
) or invoice.status == Invoice.InvoiceStatus.CART:
messages.info(request, _("Cart changed while in checkout process"))
return redirect('vendor:cart')
processor = payment_processor(invoice)
processor.set_billing_address_form_data(
request.session.get('billing_address_form'), BillingAddressForm)
processor.set_payment_info_form_data(
request.session.get('credit_card_form'), CreditCardForm)
processor.authorize_payment()
if processor.transaction_submitted:
return redirect('vendor:purchase-summary', uuid=invoice.uuid)
else:
# TODO: Make message configurable for the site in the settings
messages.info(self.request,
_("The payment gateway did not authorize payment."))
return redirect('vendor:checkout-account')
def post(self, request, *args, **kwargs):
context = super().get_context_data(**kwargs)
invoice = get_purchase_invoice(request.user,
get_site_from_request(request))
if not invoice.order_items.count(
) or invoice.status == Invoice.InvoiceStatus.CART:
messages.info(request, _("Cart changed while in checkout process"))
return redirect('vendor:cart')
credit_card_form = CreditCardForm(request.POST)
if request.POST.get('same_as_shipping') == 'on':
billing_address_form = BillingAddressForm(
instance=invoice.shipping_address)
billing_address_form.data = billing_address_form.initial
billing_address_form.is_bound = True
else:
billing_address_form = BillingAddressForm(request.POST)
if not (billing_address_form.is_valid()
and credit_card_form.is_valid()):
processor = payment_processor(invoice)
context['billing_address_form'] = billing_address_form
context['credit_card_form'] = credit_card_form
return render(request, self.template_name,
processor.get_checkout_context(context=context))
else:
billing_address_form.full_clean()
credit_card_form.full_clean()
request.session[
'billing_address_form'] = billing_address_form.cleaned_data
request.session['credit_card_form'] = credit_card_form.cleaned_data
return redirect('vendor:checkout-review')
def post(self, request, *args, **kwargs):
form = AccountInformationForm(request.POST)
if not form.is_valid():
return render(request, self.template_name, {'form': form})
shipping_address = form.save(commit=False)
invoice = get_purchase_invoice(request.user,
get_site_from_request(request))
if not invoice.order_items.count(
) or invoice.status == Invoice.InvoiceStatus.CART:
messages.info(request, _("Cart changed while in checkout process"))
return redirect('vendor:cart')
invoice.status = Invoice.InvoiceStatus.CHECKOUT
invoice.customer_notes = {
'remittance_email': form.cleaned_data['email']
}
# TODO: Need to add a drop down to select existing address
shipping_address, created = invoice.profile.get_or_create_address(
shipping_address)
if created:
shipping_address.profile = invoice.profile
shipping_address.save()
invoice.shipping_address = shipping_address
invoice.save()
return redirect('vendor:checkout-payment')
def __init__(self, *args, **kwargs):
request = kwargs.pop('request')
super(OfferForm, self).__init__(*args, **kwargs)
self.fields['start_date'].widget.attrs['class'] = 'datepicker'
self.fields['end_date'].widget.attrs['class'] = 'datepicker'
self.fields['term_start_date'].widget.attrs['class'] = 'datepicker'
self.fields['available'].label = _('Available to Purchase')
self.fields['products'].queryset = Product.objects.filter(site=get_site_from_request(request), available=True)
def get_queryset(self):
try:
# The profile and user are site specific so this should only return what's on the site for that user excluding the cart
return self.request.user.customer_profile.get(
site=get_site_from_request(self.request)).invoices.filter(
status__gt=Invoice.InvoiceStatus.CART)
except ObjectDoesNotExist: # Catch the actual error for the exception
return [] # Return empty list if there is no customer_profile
def get(self, request, *args, **kwargs):
context = super().get_context_data(**kwargs)
customer_profile, created = request.user.customer_profile.get_or_create(
site=get_site_from_request(request))
subscriptions = customer_profile.get_recurring_receipts()
context['payments'] = customer_profile.payments.filter(success=True)
context["offers"] = Offer.objects.filter(
site=get_site_from_request(request),
available=True).order_by('terms')
if subscriptions:
context['subscription'] = subscriptions.first()
context['payment'] = subscriptions.first(
).order_item.invoice.payments.filter(success=True).first()
context['payment_form'] = CreditCardForm(
initial={'payment_type': PaymentTypes.CREDIT_CARD})
return render(request, self.template_name, context)
def convert_session_cart_to_invoice(sender, request, **kwargs):
if 'session_cart' in request.session:
profile, created = request.user.customer_profile.get_or_create(
site=get_site_from_request(request))
cart = profile.get_cart()
for offer_key in request.session['session_cart'].keys():
cart.add_offer(Offer.objects.get(pk=offer_key),
quantity=request.session['session_cart'][offer_key]
['quantity'])
del (request.session['session_cart'])
def get(self, request, *args, **kwargs):
invoice = get_purchase_invoice(request.user,
get_site_from_request(request))
if not invoice.order_items.count():
return redirect('vendor:cart')
context = super().get_context_data()
processor = payment_processor(invoice)
context = processor.get_checkout_context(context=context)
return render(request, self.template_name, context)
def get_queryset(self):
try:
receipts = self.request.user.customer_profile.get(
site=get_site_from_request(self.request)).receipts.filter(
status__gte=PurchaseStatus.COMPLETE)
except ObjectDoesNotExist:
raise Http404(_("Not Found"))
subscriptions = [
receipt for receipt in receipts.all()
if receipt.order_item.offer.terms > TermType.PERPETUAL
and receipt.order_item.offer.terms < TermType.ONE_TIME_USE
]
return subscriptions
def user_has_product(self):
"""
Check to see if a user has a viable product license based on the get_product_queryset() method.
TODO: move this to some kind of caching or session variable to avoid hitting the DB on every request.
"""
if self.request.user.is_anonymous:
self.product_owned = False
else:
products = self.get_product_queryset()
self.product_owned = self.request.user.customer_profile.filter(
site=get_site_from_request(self.request)).get().has_product(
products)
return self.product_owned
def post(self, request, *args, **kwargs):
site = get_site_from_request(request)
receipt = get_object_or_404(Receipt,
profile__site=site,
uuid=self.request.POST.get('receipt_uuid'))
offer = get_object_or_404(Offer,
site=site,
uuid=self.request.POST.get('offer_uuid'))
processor = get_site_payment_processor(site)(
receipt.order_item.invoice)
processor.subscription_update_price(receipt, offer.current_price(),
request.user)
return redirect(request.META.get('HTTP_REFERER', self.success_url))
def get_product_queryset(self):
"""
Method to get the Product(s) needed for the check. Can be overridden to handle complex queries.
"""
if self.product_queryset is None:
if self.product_model:
# Only provide list of products on the current site.
return self.product_model.objects.filter(
site=get_site_from_request(self.request))
else:
raise ImproperlyConfigured(
"%(cls)s is missing a Product QuerySet. Define "
"%(cls)s.product_model, %(cls)s.product_queryset, or override "
"%(cls)s.get_product_queryset()." %
{'cls': self.__class__.__name__})
return self.product_queryset.all()
def get(self, request, *args, **kwargs):
invoice = get_purchase_invoice(request.user,
get_site_from_request(request))
if not invoice.order_items.count():
return redirect('vendor:cart')
context = super().get_context_data()
processor = payment_processor(invoice)
if 'billing_address_form' in request.session:
context['billing_address_form'] = BillingAddressForm(
request.session['billing_address_form'])
if 'credit_card_form' in request.session:
context['credit_card_form'] = CreditCardForm(
request.session['credit_card_form'])
context = processor.get_checkout_context(context=context)
return render(request, self.template_name, context)
def get_queryset(self):
# TODO: Update to handle ranges from a POST
if hasattr(self.request, 'site'):
return self.model.objects.filter(
site=get_site_from_request(self.request))
return self.model.on_site.all()
def get_queryset(self):
if hasattr(self.request, 'site'):
return self.model.objects.filter(
site=get_site_from_request(self.request))
return self.model.on_site.all()
def get_queryset(self):
return self.request.user.customer_profile.get(
site=get_site_from_request(self.request)).receipts.filter(
status__gte=PurchaseStatus.COMPLETE)
def get(self, request, *args, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = self.model.objects.get(
site=get_site_from_request(request), slug=kwargs['slug'])
return render(request, self.template_name, context)
