def Confirm_Purchase(request, id):
# Get cart item
item = get_object_or_404(models.Clothing_Post, id=id)
if request.method == "POST":
firstName = request.POST.get("firstName")
lastName = request.POST.get("lastName")
address = request.POST.get("address")
# User wants to buy
Payment = get_payment_model()
payment = Payment.object.create(
variant = "default",
description = "Purchase of Clothing",
total = Item.Price,
billing_first_name = firstName,
billing_last_name = lastName,
billing_address_1 = address
)
payment = get_object_or_404(get_payment_model(), Item=item)
# try:
# form = payment.get_form(data=request.POST or None)
# except RedirectNeeded as redirect_to:
# return redirect(str(redirect_to))
form = payment
return render(request, "Clothes/Purchase_Confirm.html", {"item":item, 'form':form})
def payment_details(request, payment_id):
payment = get_object_or_404(get_payment_model(), id=payment_id)
try:
form = payment.get_form(data=request.POST or None)
except RedirectNeeded as redirect_to:
return redirect(str(redirect_to))
return TemplateResponse(request, 'payment.html', {'form': form, 'payment': payment})
def __init__(self, data, service_type):
self.data = data
self.service_type = service_type
self.payment_id = self.data.get('payment_id', None)
self.provider = provider_factory('click')
self.payment = get_object_or_404(get_payment_model(),
id=self.payment_id)
super(Services, self).__init__(self.provider, self.payment, self.data)
def payment_details(request, pk):
payment = get_object_or_404(get_payment_model(), pk=pk)
try:
form = payment.get_form(data=request.POST or None)
except RedirectNeeded as redirect_to:
return redirect(str(redirect_to))
return TemplateResponse(request, 'payment.html',
{'form': form, 'payment': payment})
def payment_details(request, payment_id):
payment = get_object_or_404(get_payment_model(), id=payment_id)
try:
form = payment.get_form(data=request.POST or None)
except RedirectNeeded as redirect_to:
return redirect(str(redirect_to))
return TemplateResponse(request, "payment.html", {
"form": form,
"payment": payment
})
def payment_details(self, id):
"""The route for this function is called by django-payments after a registration is submitted. """
print('========== views function - payment_details ==============')
payment = get_object_or_404(get_payment_model(), id=id)
try:
form = payment.get_form(data=self.POST or None)
except RedirectNeeded as redirect_to:
print('---- payment_details redirected -------')
return redirect(str(redirect_to))
print('------ payment_details TemplateResponse ---------')
return TemplateResponse(self, 'payment/payment.html',
{'form': form, 'payment': payment})
def payment_details(request, payment_id=None):
payment = get_object_or_404(get_payment_model(), id=payment_id)
payment.id = 1005
payment.currency = 'CZK'
try:
form = payment.get_form(data=request.GET or None)
except RedirectNeeded as redirect_to:
return redirect(str(redirect_to))
return TemplateResponse(request, 'payment.html', {
'form': form,
'payment': payment
})
def get_token_from_request(self, request=None, payment=None):
if request.method == 'GET':
# Redirect not webhook
source_id = request.GET.get('source')
if source_id is None:
return None
Payment = get_payment_model()
try:
payment = Payment.objects.get(transaction_id=source_id, )
except Payment.DoesNotExist:
return None
return payment.token
return super().get_token_from_request(request=request, payment=payment)
def process_data(request, token, provider=None):
'''
Calls process_data of an appropriate provider.
Raises Http404 if variant does not exist.
'''
Payment = get_payment_model()
payment = get_object_or_404(Payment, token=token)
if not provider:
try:
provider = provider_factory(payment.variant)
except ValueError:
raise Http404('No such payment')
return provider.process_data(payment, request)
def get_token_from_request(self, request=None, payment=None):
'''
Extract payment token from webhook
via payment intent's id == payment.transaction_id
'''
event_dict = self.decode_webhook_request(request)
if event_dict is None:
return None
obj = event_dict['data']['object']
Payment = get_payment_model()
try:
payment = Payment.objects.get(transaction_id=obj['id'], )
except Payment.DoesNotExist:
return None
return payment.token
def get_context_data(self, **kwargs):
context = super(OrderView, self).get_context_data(**kwargs)
payment, created = get_payment_model().objects.get_or_create(
order__pk=self.object.pk,
defaults={
'variant': 'default',
'description': 'Plan Purchase',
'order': self.object,
'total': self.object.total(),
'tax': self.object.tax_total(),
'currency': self.object.currency
})
context['payment_form'] = payment.get_form()
context['payment'] = payment
return context
def payment(db) -> BasePayment:
Payment = get_payment_model()
return Payment.objects.create(
variant="przelewy24", # this is the variant from PAYMENT_VARIANTS
description="Book purchase",
total=Decimal(120.24),
tax=Decimal(20),
currency="PLN",
delivery=Decimal(10),
billing_first_name="Sherlock",
billing_last_name="Holmes",
billing_address_1="221B Baker Street",
billing_address_2="",
billing_city="London",
billing_postcode="NW1 6XE",
billing_country_code="GB",
billing_country_area="Greater London",
customer_ip_address="127.0.0.1",
)
def create_payment(request, payment_variant, order_id):
order = get_object_or_404(Order, pk=order_id)
Payment = get_payment_model()
payment = Payment.objects.create(
variant=payment_variant,
order=order,
description='Subscription plan %s purchase' % order.name,
total=Decimal(order.total()),
tax=Decimal(order.tax_total()),
currency=order.currency,
delivery=Decimal(0),
billing_first_name=settings.PLANS_INVOICE_ISSUER['issuer_name'],
# billing_last_name=settings.PLANS_INVOICE_ISSUER['issuer_'],
billing_address_1=settings.PLANS_INVOICE_ISSUER['issuer_street'],
# billing_address_2=settings.PLANS_INVOICE_ISSUER['issuer_'],
billing_city=settings.PLANS_INVOICE_ISSUER['issuer_city'],
billing_postcode=settings.PLANS_INVOICE_ISSUER['issuer_zipcode'],
billing_country_code=settings.PLANS_INVOICE_ISSUER['issuer_country'],
# billing_country_area=settings.PLANS_INVOICE_ISSUER['issuer_name'],
customer_ip_address='127.0.0.1')
return redirect(
reverse('payment_details', kwargs={'payment_id': payment.id}))
def checkout(request):
form = CreditCardPaymentFormWithName()
if request.POST:
Payment = get_payment_model()
payment = Payment.objects.create(
variant='default', # this is the variant from PAYMENT_VARIANTS
description='',
total=Decimal(120),
tax=Decimal(20),
currency='MXN',
delivery=Decimal(10),
billing_first_name='Carlos',
billing_last_name='Fuentes',
billing_address_1='UNAM CU, Facultad de Ingenieria',
billing_address_2='',
billing_city='Mexico City',
billing_postcode='56617',
billing_country_code='MX',
billing_country_area='Mexico',
customer_ip_address='127.0.0.1')
return redirect('/')
return render(request, 'payment.html', {'form': form})
return render(request, 'poster/Search.html', {'form': form})
def payment_details(request, payment_id):
payment = get_object_or_404(get_payment_model(), id=payment_id)
try:
form = payment.get_form(data=request.POST or None)
except RedirectNeeded as redirect_to:
return redirect(str(redirect_to))
return TemplateResponse(request, 'poster/payment.html', {
'form': form,
'payment': payment
})
Payment = get_payment_model()
payment = Payment.objects.create(
variant='default', # this is the variant from PAYMENT_VARIANTS
description='Book purchase',
total=Decimal(120),
tax=Decimal(20),
currency='USD',
delivery=Decimal(10),
billing_first_name='Sherlock',
billing_last_name='Holmes',
billing_address_1='221B Baker Street',
billing_address_2='',
billing_city='London',
billing_postcode='NW1 6XE',
billing_country_code='UK',
billing_country_area='Greater London',
def form_valid(self, form):
form_data = form.cleaned_data
if 'order_in_session' in self.request.session:
try:
order = SoftwareOrder.objects.get(pk=self.request.session['order_in_session'])
except SoftwareOrder.DoesNotExist:
order = SoftwareOrder()
else:
order = SoftwareOrder()
cart = Cart(self.request.session)
order.total = cart.total
order.user = self.request.user
order.company = self.request.user.company
order.first_name = self.request.user.first_name
order.last_name = self.request.user.last_name
order.email = self.request.user.email
order.city = self.request.user.city
order.state = self.request.user.state
order.country = self.request.user.country
order.phone = self.request.user.phone
order.is_completed = False
order.save()
self.request.session['order_in_session'] = order.pk
order.items.all().delete()
for item in cart.items:
order_item = SoftwareOrderItem()
order_item.software = item.product.software
order_item.quantity = item.quantity
order_item.price = item.price
order_item.name = "%s" % item.product
order_item.sku = item.product.software.sku
order_item.order = order
order_item.save()
if item.product.modules.exists():
order_item.modules = item.product.modules.all()
module_names = []
module_skus = []
for module in order_item.modules.all():
module_names.append(module.name)
module_skus.append(module.sku)
order_item.name = "%s Plus %s" % (order_item.name, ", ".join(module_names))
order_item.sku = "%s %s" % (order_item.sku, " ".join(module_skus))
order_item.save()
self.request.session['billing_details'] = {
'billing_first_name': form_data['billing_first_name'],
'billing_last_name': form_data['billing_last_name'],
'billing_company': form_data['billing_company'],
'billing_country_code': form_data['billing_country_code'],
'billing_city': form_data['billing_city'],
'billing_country_area': form_data['billing_country_area'],
'billing_address_1': form_data['billing_address_1'],
'billing_address_2': form_data['billing_address_2'],
'billing_postcode': form_data['billing_postcode']
}
Payment = get_payment_model()
payment = Payment.objects.create(
variant=form_data['pay_method'], # this is the variant from PAYMENT_VARIANTS
description=order.order_code,
order=order,
user=self.request.user,
total=cart.total,
tax=Decimal(0),
currency=settings.DEFAULT_CURRENCY,
delivery=Decimal(0),
billing_first_name=form_data['billing_first_name'],
billing_last_name=form_data['billing_last_name'],
billing_company=form_data['billing_company'],
billing_address_1=form_data['billing_address_1'],
billing_address_2=form_data['billing_address_2'],
billing_city=form_data['billing_city'],
billing_postcode=form_data['billing_postcode'],
billing_country_code=form_data['billing_country_code'],
billing_country_area=form_data['billing_country_area'],
customer_ip_address=self.request.META.get('REMOTE_ADDR'))
return redirect(reverse('checkout-payment', args=[payment.pk]))
def order_load(payment_id):
if int(payment_id) > 1000000000:
return None
payment = get_object_or_404(get_payment_model(), id=int(payment_id))
return payment
from django.http.response import Http404, HttpResponseForbidden
from django.shortcuts import redirect
from django.template.response import TemplateResponse
from order import check_order_status
from payment.forms import PaymentMethodsForm, PaymentDeledeForm
from payments import RedirectNeeded, get_payment_model
Payment = get_payment_model()
@check_order_status
def index(request, order):
form = PaymentMethodsForm(request.POST or None)
try:
waiting_payment = order.payments.get(status='waiting')
except Payment.DoesNotExist:
waiting_payment = None
waiting_payment_form = None
else:
waiting_payment_form = PaymentDeledeForm(
None, order=order, initial={'payment_id': waiting_payment.id})
if form.is_valid() and not waiting_payment:
payment_method = form.cleaned_data['method']
return redirect('order:payment:details', token=order.token,
variant=payment_method)
return TemplateResponse(request, 'payment/index.html',
{'form': form, 'order': order,
'waiting_payment': waiting_payment,
'waiting_payment_form': waiting_payment_form})
def get_payment_by_id(self, transaction_id):
Payment = get_payment_model()
try:
return Payment.objects.get(transaction_id=transaction_id, )
except Payment.DoesNotExist:
return None
