def post_transaction(request, key):
if request.method == 'POST':
ser = PaymentPOSTData(data=request.data)
if ser.is_valid():
logger.debug('data is ' + str(ser.data))
amount = ser.validated_data.get('amount')
payment_method_name = ser.validated_data.get('name')
method = get_method_by_name(payment_method_name)
payment_nonce = ser.validated_data.get('payment_nonce')
name = "Urongo Krompf"
email = "*****@*****.**" # ser.validated_data.get('email1')
show_name = True # not ser.validated_data['hide_name']
# Create a new payment transaction with a random ID.
transaction_id = str(uuid.uuid4())
perk_id = None
# if perk != None:
# perk_id = perk.id
PledgePaymentCommand(transaction_id, key, amount, email, perk_id, name, show_name,
payment_method_name)
transaction = Transaction.objects.get(transaction_id=transaction_id)
if method.validate_nonce(amount, payment_nonce):
logger.debug('transaction is good')
ReceivePaymentCommand(transaction_id, amount, request)
return Response(TransactionSerializer(transaction).data)
else:
logger.debug('transaction is bad')
return Response(TransactionSerializer(transaction).data)
else:
logger.debug("got a wrong http method")
return Response({'result': 'error', 'errors': ser.errors})
def post_transaction(request, key):
if request.method == "POST":
ser = PaymentPOSTData(data=request.data)
if ser.is_valid():
logger.debug("data is " + str(ser.data))
amount = ser.validated_data.get("amount")
payment_method_name = ser.validated_data.get("name")
method = get_method_by_name(payment_method_name)
payment_nonce = ser.validated_data.get("payment_nonce")
name = "Urongo Krompf"
email = "*****@*****.**" # ser.validated_data.get('email1')
show_name = True # not ser.validated_data['hide_name']
# Create a new payment transaction with a random ID.
transaction_id = str(uuid.uuid4())
perk_id = None
# if perk != None:
# perk_id = perk.id
BeginPayment(transaction_id, key, amount, email, perk_id, name, show_name, payment_method_name)
transaction = Transaction.objects.get(transaction_id=transaction_id)
if method.validate_nonce(amount, payment_nonce):
logger.debug("transaction is good")
ReceivePayment(transaction_id, amount, request)
return Response(TransactionSerializer(transaction).data)
else:
logger.debug("transaction is bad")
return Response(TransactionSerializer(transaction).data)
else:
logger.debug("got a wrong http method")
return Response({"result": "error", "errors": ser.errors})
def select_payment(request, key):
"""
The user has clicked the "Pledge now" button. Let's show him the list of
available Payment methods
"""
campaign = get_campaign_or_404(request, key)
perk_id = request.GET.get('perk', None)
pledge_value = Decimal('0.0')
perk = None
if perk_id != None:
perk = get_object_or_404(Perk, pk=int(perk_id))
pledge_value = perk.amount
methods = get_payment_methods()
context = {
'campaign': campaign,
'selected_perk': perk,
'methods': methods,
'pledge_value': pledge_value,
}
if request.method == 'POST':
form = forms.SelectPaymentForm(campaign, perk, request.POST)
if form.is_valid():
amount = form.cleaned_data.get('amount')
payment_method_name= form.cleaned_data.get('payment_method')
method = get_method_by_name(payment_method_name)
email = form.cleaned_data.get('email1')
name = form.cleaned_data.get('name')
show_name = not form.cleaned_data['hide_name']
# Create a new payment transaction with a random ID.
transaction_id = str(uuid.uuid4())
perk_id = None
if perk != None:
perk_id = perk.id
PledgePaymentCommand(transaction_id, campaign.key, amount, email, perk_id,
name, show_name)
UnverifyPaymentCommand(transaction_id, payment_method_name)
# Delegate the payment transaction to the pay() method of the selected
# payment method. The method will then redirect the user to the page it needs
# to complete the payment.
return method.pay(request, campaign, transaction_id)
else:
return render(request, 'campaigns/select_payment.html', dict(context, form=form))
else:
return render(request, 'campaigns/select_payment.html', context)
def select_payment(request, key):
"""
The user has clicked the "Pledge now" button. Let's show him the list of
available Payment methods
"""
campaign = get_campaign_or_404(request, key)
perk_id = request.GET.get("perk", None)
pledge_value = Decimal("0.0")
perk = None
if perk_id != None:
perk = get_object_or_404(Perk, pk=int(perk_id))
pledge_value = perk.amount
methods = get_payment_methods()
context = {"campaign": campaign, "selected_perk": perk, "methods": methods, "pledge_value": pledge_value}
if request.method == "POST":
form = forms.SelectPaymentForm(campaign, perk, request.POST)
if form.is_valid():
amount = form.cleaned_data.get("amount")
payment_method_name = form.cleaned_data.get("payment_method")
method = get_method_by_name(payment_method_name)
email = form.cleaned_data.get("email1")
name = form.cleaned_data.get("name")
show_name = not form.cleaned_data["hide_name"]
# Create a new payment transaction with a random ID.
transaction_id = str(uuid.uuid4())
perk_id = None
if perk != None:
perk_id = perk.id
BeginPayment(transaction_id, campaign.key, amount, email, perk_id, name, show_name, payment_method_name)
# Delegate the payment transaction to the pay() method of the selected
# payment method. The method will then redirect the user to the page it needs
# to complete the payment.
return method.pay(request, campaign, transaction_id)
else:
return render(request, "campaigns/select_payment.html", dict(context, form=form))
else:
return render(request, "campaigns/select_payment.html", context)
def pay_with(request, key, name):
campaign = get_object_or_404(Campaign, key=key)
method = get_method_by_name(name)
return Response(method.get_json())
def braintree_method():
payment_method = get_method_by_name('braintree')
return payment_method
def payment_form(request, transaction_id, payment_method_name):
"""
Show a payment form to the user.
"""
transact = get_object_or_404(Transaction, transaction_id=transaction_id)
if transact.state != Transaction.STATE_UNVERIFIED:
return render(request, 'yldt_braintree/transaction_error.html',
{'transaction': transact})
payment_method = get_method_by_name(payment_method_name)
first_name, last_name = transact.name.split(' ', 1)
amount = transact.amount
fee = payment_method.calculate_fee(amount)
total = amount + fee
# process the payment data and show the results.
if request.method == "POST":
form = BrainTreeForm(request.POST)
if form.is_valid():
result = create_customer(request, transaction, nonce_from_the_client)
if result.is_success:
store_verification_result(result)
url = '/pay/{}/{}/success/'.format(payment_method_name, transaction_id)
return HttpResponseRedirect(url)
else:
context = {
'braintree_error': result.message,
'amount': amount,
'fee': fee,
'total': total,
'is_sandbox': payment_method.is_sandbox(),
'transaction': transact,
'client_token': payment_method.get_client_token(),
'form': form,
}
return render(request, 'yldt_braintree/payment_form.html', context)
# The user entered invalid data
else:
print('{}'.format(form.errors))
context = {
'transaction': transact,
'amount': amount,
'fee': fee,
'total': total,
'is_sandbox': payment_method.is_sandbox(),
'client_token': payment_method.get_client_token(),
'form': form,
}
return render(request, 'yldt_braintree/payment_form.html', context)
# show the payment form to the user.
else:
context = {
'transaction': transact,
'amount': amount,
'fee': fee,
'total': total,
'is_sandbox': payment_method.is_sandbox(),
'client_token': payment_method.get_client_token(),
'form': BrainTreeForm(),
}
return render(request, 'yldt_braintree/payment_form.html', context)
def payment_form(request, transaction_id, payment_method_name):
"""
Show a payment form to the user.
"""
transact = get_object_or_404(Transaction, transaction_id=transaction_id)
if transact.state != Transaction.STATE_OPEN:
return render(request, "yldt_braintree/transaction_error.html", {"transaction": transact})
payment_method = get_method_by_name(payment_method_name)
first_name, last_name = transact.name.split(" ", 2)
email = transact.email
amount = transact.amount
fee = payment_method.calculate_fee(amount)
total = amount + fee
# process the payment data and show the results.
if request.method == "POST":
form = BrainTreeForm(request.POST)
if form.is_valid():
result = braintree.Customer.create(
{
"first_name": first_name,
"last_name": last_name,
"email": email,
"payment_method_nonce": form.cleaned_data["payment_method_nonce"],
# "custom_fields": {
# "yldt_campaign_key": transact.campaign.key,
# "yldt_transaction_id": transact.transaction_id,
# "yldt_amount": amount,
# "yldt_perk_id": transact.perk.id if transact.perk != None else None,
# }
}
)
if result.is_success:
bt, _ = BrainTreeTransaction.objects.get_or_create(transaction_id=transact.transaction_id)
bt.braintree_customer_id = result.customer.id
bt.save()
ReceivePayment(transaction_id, transact.amount, request)
url = "/pay/{}/{}/success/".format(payment_method_name, transaction_id)
return HttpResponseRedirect(url)
else:
context = {
"braintree_error": result.message,
"amount": amount,
"fee": fee,
"total": total,
"is_sandbox": payment_method.is_sandbox(),
"transaction": transact,
"client_token": payment_method.get_client_token(),
"form": form,
}
return render(request, "yldt_braintree/payment_form.html", context)
# The user entered invalid data
else:
print form.errors
context = {
"transaction": transact,
"amount": amount,
"fee": fee,
"total": total,
"is_sandbox": payment_method.is_sandbox(),
"client_token": payment_method.get_client_token(),
"form": form,
}
return render(request, "yldt_braintree/payment_form.html", context)
# show the payment form to the user.
else:
context = {
"transaction": transact,
"amount": amount,
"fee": fee,
"total": total,
"is_sandbox": payment_method.is_sandbox(),
"client_token": payment_method.get_client_token(),
"form": BrainTreeForm(),
}
return render(request, "yldt_braintree/payment_form.html", context)
def setUp(self):
self.payment_method = get_method_by_name('braintree')
self.transaction = Mock()
self.transaction.amount = Decimal('23.42')
def braintree_method():
payment_method = get_method_by_name('braintree')
return payment_method
def setUp(self):
self.payment_method = get_method_by_name('braintree')
self.transaction = Mock()
self.transaction.amount = Decimal('23.42')
def payment_form(request, transaction_id, payment_method_name):
"""
Show a payment form to the user.
"""
transact = get_object_or_404(Transaction, transaction_id=transaction_id)
if transact.state != Transaction.STATE_UNVERIFIED:
return render(request, 'yldt_braintree/transaction_error.html',
{'transaction': transact})
payment_method = get_method_by_name(payment_method_name)
first_name, last_name = transact.name.split(' ', 1)
amount = transact.amount
fee = payment_method.calculate_fee(amount)
total = amount + fee
# process the payment data and show the results.
if request.method == "POST":
form = BrainTreeForm(request.POST)
if form.is_valid():
result = create_customer(request, transaction,
nonce_from_the_client)
if result.is_success:
store_verification_result(result)
url = '/pay/{}/{}/success/'.format(payment_method_name,
transaction_id)
return HttpResponseRedirect(url)
else:
context = {
'braintree_error': result.message,
'amount': amount,
'fee': fee,
'total': total,
'is_sandbox': payment_method.is_sandbox(),
'transaction': transact,
'client_token': payment_method.get_client_token(),
'form': form,
}
return render(request, 'yldt_braintree/payment_form.html',
context)
# The user entered invalid data
else:
print('{}'.format(form.errors))
context = {
'transaction': transact,
'amount': amount,
'fee': fee,
'total': total,
'is_sandbox': payment_method.is_sandbox(),
'client_token': payment_method.get_client_token(),
'form': form,
}
return render(request, 'yldt_braintree/payment_form.html', context)
# show the payment form to the user.
else:
context = {
'transaction': transact,
'amount': amount,
'fee': fee,
'total': total,
'is_sandbox': payment_method.is_sandbox(),
'client_token': payment_method.get_client_token(),
'form': BrainTreeForm(),
}
return render(request, 'yldt_braintree/payment_form.html', context)
def pay_with(request, key, name):
campaign = get_object_or_404(Campaign, key=key)
method = get_method_by_name(name)
return Response(method.get_json())
