def get_order(self, order_id):
# Method to get order
request = OrdersGetRequest(order_id)
# 3. Call PayPal to get the transaction
response = self.client.execute(request)
return response
def get_order(self, order_id):
"""Method to get order"""
request = OrdersGetRequest(order_id)
# 3. Call PayPal to get the transaction
response = self.client.execute(request)
# 4. Save the transaction in your database. Implement logic to save transaction to your database for future reference.
return response
def get_order(self, order_id):
"""Method to get order"""
request = OrdersGetRequest(order_id)
# 3. Call PayPal to get the transaction
# TODO: error handling on paypal check.
response = self.client.execute(request)
# 4. Save the transaction in your database. Implement logic to save transaction to your database for future reference.
print('Status Code: ', response.status_code)
print('Status: ', response.result.status)
print('Order ID: ', response.result.id)
print('Intent: ', response.result.intent)
print('Gross Amount: {} {}'.format(
response.result.purchase_units[0].amount.currency_code,
response.result.purchase_units[0].amount.value))
return (
response.result.purchase_units[0].amount, # amount
response.result.purchase_units[0].reference_id, # buy order id
response.result.purchase_units[0].
description, # seller id / sell order id
response.result.purchase_units[0].payments.
captures[0], # payment detail status
response.result)
def testOrderGetRequestTest(self):
response = create_order(self.client)
request = OrdersGetRequest(response.result.id)
response = self.client.execute(request)
self.assertEqual(200, response.status_code)
self.assertIsNotNone(response.result)
self.assertIsNotNone(response.result.id)
self.assertIsNotNone(response.result.purchase_units)
self.assertEqual(1, len(response.result.purchase_units))
first_purchase_unit = response.result.purchase_units[0]
self.assertEqual("test_ref_id1", first_purchase_unit.reference_id)
self.assertEqual("USD", first_purchase_unit.amount.currency_code)
self.assertEqual("100.00", first_purchase_unit.amount.value)
self.assertIsNotNone(response.result.create_time)
self.assertIsNotNone(response.result.links)
found_approve = False
for link in response.result.links:
if "approve" == link.rel:
found_approve = True
self.assertIsNotNone(link.href)
self.assertEqual("GET", link.method)
self.assertTrue(found_approve)
self.assertEqual("CREATED", response.result.status)
def get_paypal_order(token) -> dict:
request = OrdersGetRequest(token)
response = client.execute(request)
return {
'buyer_email' : response.result.payer['email_address'],
'payment_status' : response.result.status
}
def get(self, request, orderID):
try:
# Get paypal request
requestPaypal = OrdersGetRequest(orderID)
response = PayPalClient().client.execute(requestPaypal)
# check payment status
if response.result.status == "COMPLETED":
amount = response.result.purchase_units[0].amount.value
# check if exists the "OrderID" in the orders
if Order.objects.filter(
PayPalOrderId=response.result.id).exists():
return render(request, "payment.html",
{"successMessage": "Successful Payment"})
else:
try:
order = Order.objects.get(User=request.user,
Ordered=False)
# verify if "payment amount" and "order.Total" are equal
if float(amount) == float(order.Total):
# save the payment data
order.Ordered = True
order.PayPalOrderId = response.result.id
order.Date = datetime.now()
OrderItem.objects.filter(
id__in=order.Items.all()).update(Ordered=True)
order.save()
# remove all books from the cart
clearCart(request)
return render(
request, "payment.html",
{"successMessage": "Successful Payment"})
else:
return render(
request, "payment.html", {
"errorMessage":
"The payment amount not match with the server"
})
except ObjectDoesNotExist:
try:
order = Order.objects.get(
PayPalOrderId=response.result.id, Ordered=True)
return render(
request, "payment.html",
{"successMessage": "Successful Payment"})
except ObjectDoesNotExist:
return render(
request, "payment.html",
{"errorMessage": "Server Internal Error"})
except Exception:
return redirect("core:home")
def confirm_payment(self):
try:
order_id = self.details['id']
except KeyError:
order_id = None
if order_id:
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
return response.result.id
def get_order_and_update(self, order_id, user):
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
current_amount = PaymentsApp.models.AvailableAmount.objects.get(
user=user)
PaymentsApp.models.AvailableAmount.objects.filter(
user=user).update(available_amount=float(
response.result.purchase_units[0].amount.value) +
getattr(current_amount, 'available_amount'))
def get_payment(self, order_id: str) -> HttpResponse:
"""
Retrieve details for a PayPal payment
:param order_id: ID of the PayPal payment
:return: The response of the API call to PayPal
"""
request = OrdersGetRequest(order_id)
return self.client.execute(request)
def __order_get_request(self, token):
request = OrdersGetRequest(token)
response = self.paypal.execute(request)
print(f"查询 {token} 订单数据")
self.__print_paypal_response(response)
_pid = response.result.id
_purchase_units = response.result.purchase_units[0]
_status = response.result.status
_sid = _purchase_units['invoice_id']
return _sid, _pid, _status
def get_order(self, order_id):
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
print('Status Code: ', response.status_code)
print('Status: ', response.result.status)
print('Order ID: ', response.result.id)
print('Intent: ', response.result.intent)
print('Links:')
for link in response.result.links:
print('\t{}: {}\tCall Type: {}'.format(link.rel, link.href,
link.method))
print('Gross Amount: {} {}'.format(
response.result.purchase_units[0].amount.currency_code,
response.result.purchase_units[0].amount.value))
def get_order(self, order_id):
"""Query the PayPal api for information about the order. Return the
amount of the payment (in cents) upon success or 0 otherwise
"""
try:
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
except HttpError as e:
logger.error('HttpError while fetching PayPal order: {}'.format(e))
return '', 0
try:
assert response.result.intent == 'CAPTURE', 'bad payment intent'
assert response.status_code == 200, 'bad http response code'
assert response.result.status == 'COMPLETED', 'tx not completex'
assert response.result.id == order_id, 'order id does not match'
purchase = response.result.purchase_units[0]
srb = purchase.payments.captures[0].seller_receivable_breakdown
assert srb.paypal_fee.currency_code == 'USD', 'foreign currency'
assert srb.net_amount.currency_code == 'USD', 'foreign currency'
assert srb.gross_amount.currency_code == 'USD', 'foreign currency'
parts = srb.paypal_fee.value.split('.')
fee = int(parts[0]) * 100 + int(parts[1])
assert fee > 0, 'invalid fee amount'
parts = srb.net_amount.value.split('.')
net = int(parts[0]) * 100 + int(parts[1])
assert fee > 0, 'invalid net amount'
parts = srb.gross_amount.value.split('.')
gross = int(parts[0]) * 100 + int(parts[1])
assert fee > 0, 'invalid gross amount'
assert fee + net == gross, 'conversion error'
payment_id = purchase.payments.captures[0].id
assert payment_id, 'missing paypal TransactionID'
except AssertionError as e:
logger.error(
'AssertionError while fetching PayPal order: {}'.format(e))
return '', 0
return payment_id, net, fee
def get_order(self, order_id):
"""Method to get order"""
request = OrdersGetRequest(order_id)
#3. Call PayPal to get the transaction
response = self.client.execute(request)
#4. Save the transaction in your database. Implement logic to save transaction to your database for future reference.
print ('Status Code: ', response.status_code)
print ('Status: ', response.result.status)
print ('Order ID: ', response.result.id)
print ('Intent: ', response.result.intent)
print ('Links:')
for link in response.result.links:
print('\t{}: {}\tCall Type: {}'.format(link.rel, link.href, link.method))
print ('Gross Amount: {} {}'.format(response.result.purchase_units[0].amount.currency_code,
response.result.purchase_units[0].amount.value))
def get_order(self, order_id):
"""Method to get order"""
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
print 'Status Code: ', response.status_code
print 'Status: ', response.result.status
print 'Order ID: ', response.result.id
print 'Intent: ', response.result.intent
print 'Links:'
for link in response.result.links:
print('\t{}: {}\tCall Type: {}'.format(link.rel, link.href,
link.method))
print 'Gross Amount: {} {}'.format(
response.result.purchase_units[0].amount.currency_code,
response.result.purchase_units[0].amount.value)
json_data = self.object_to_json(response.result)
print "json_data: ", json.dumps(json_data, indent=4)
def patch_order(self, order_id):
"""Method to patch order"""
request = OrdersPatchRequest(order_id)
request.request_body(self.build_request_body())
self.client.execute(request)
response = self.client.execute(OrdersGetRequest(order.id))
print('Order ID: ', response.result.id)
print('Intent: ', response.result.intent)
print('Links:')
for link in response.result.links:
print('\t{}: {}\tCall Type: {}'.format(link.rel, link.href,
link.method))
print('Gross Amount: {} {}'.format(
response.result.purchase_units[0].amount.currency_code,
response.result.purchase_units[0].amount.value))
json_data = self.object_to_json(response.result)
print("json_data: ", json.dumps(json_data, indent=4))
def get_order(self, order_id):
"""Method to get order"""
request = OrdersGetRequest(order_id)
#3. Call PayPal to get the transaction
response = self.client.execute(request)
#print(json.dumps(str(response.result.__dict__["_dict"]), indent=4).replace("},", "},\n"))
#print("Purcase Units")
#print(json.loads(json.dumps(str(response.result.purchase_units[0].__dict__), indent=4)))
#4. Save the transaction in your database. Implement logic to save transaction to your database for future reference.
#print(f'Status Code: {response.status_code}')
#print(f'Status: {response.result.status}')
#print(f'Order ID: {response.result.id}')
#print(f'Intent: {response.result.intent}')
#print('Links:')
#for link in response.result.links:
# print('\t{}: {}\tCall Type: {}'.format(link.rel, link.href, link.method))
#print('Gross Amount: {} {}'.format(response.result.purchase_units[0].amount.currency_code,
# response.result.purchase_units[0].amount.value))
return response.result.__dict__["_dict"]
async def capture_transaction(
transaction_body: CaptureTransactionModel,
identity: Optional[str] = Depends(get_jwt_identity_optional)):
try:
orderResponse = paypal_client.client.execute(
OrdersGetRequest(transaction_body.orderID))
order = Order.objects.get(
id=orderResponse.result.purchase_units[0].custom_id)
if not price_service.remove_stock(order):
raise OutOfStockError
response = paypal_client.client.execute(
OrdersCaptureRequest(transaction_body.orderID))
order.paypalCaptureID = response.result.purchase_units[
0].payments.captures[0].id
order.orderStatus = 'placed'
order.save()
return orderResponse.result.purchase_units[0].custom_id
except OutOfStockError:
raise OutOfStockError().http_exception
except Exception as e:
raise e
def payment_complete(request):
PPClient = PayPalClient()
body = json.loads(request.body)
data = body["orderID"]
user_id = request.user.id
requestorder = OrdersGetRequest(data)
response = PPClient.client.execute(requestorder)
total_paid = response.result.purchase_units[0].amount.value
basket = Basket(request)
order = Order.objects.create(
user_id=user_id,
full_name=response.result.purchase_units[0].shipping.name.full_name,
email=response.result.payer.email_address,
address1=response.result.purchase_units[0].shipping.address.
address_line_1,
address2=response.result.purchase_units[0].shipping.address.
admin_area_2,
postal_code=response.result.purchase_units[0].shipping.address.
postal_code,
country_code=response.result.purchase_units[0].shipping.address.
country_code,
total_paid=response.result.purchase_units[0].amount.value,
order_key=response.result.id,
payment_option="paypal",
billing_status=True,
)
order_id = order.pk
for item in basket:
OrderItem.objects.create(order_id=order_id,
product=item["product"],
price=item["price"],
quantity=item["qty"])
return JsonResponse("Payment completed!", safe=False)
def request_refund(self, data: BaseRequestRefund) -> bool:
request = OrdersGetRequest(data.pid)
response = self.paypal.execute(request)
capture_id = response.result.purchase_units[0].payments.captures[0].id
print(f"退款数据 {capture_id}")
self.__print_paypal_response(response)
request = CapturesRefundRequest(capture_id)
request.prefer("return=representation")
_post_data = {
"amount": {
"value": f"{data.price}",
"currency_code": self.config['currency_code']
}
}
request.request_body(_post_data)
try:
response = self.paypal.execute(request)
return True
except Exception as e:
print(e)
return False
def get_order(self, token):
request = OrdersGetRequest(token)
response = self.client.execute(request)
return response.result
def query_order(self, data: BaseOrderId) -> dict:
request = OrdersGetRequest(data.pid)
response = self.paypal.execute(request)
json_data = PayPalResultFormatUtil.object_to_json(response.result)
return json_data
def get_order_price(self, order_id):
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
return response.result.purchase_units[0].amount.value
def get_order(self, order_id, addressDetails, request):
"""Method to get order"""
addressDetails = json.loads(addressDetails)
if request.user.is_anonymous:
user = None
else:
user = request.user
if 'fullname' in addressDetails:
name = addressDetails['fullname']
else:
name = request.user.get_full_name()
total = getTotal(request)
cart = request.COOKIES.get('cart')
address = getAddress(addressDetails, request)
print(address, cart, total)
request = OrdersGetRequest(order_id)
#3. Call PayPal to get the transaction
response = self.client.execute(request)
#4. Save the transaction in your database. Implement logic to save transaction to your database for future reference.
print('Status Code: ', response)
print('Status: ', response.result)
print('Order ID: ', response.result.id)
print('Intent: ', response.result.intent)
print('Links:')
for link in response.result.links:
print('\t{}: {}\tCall Type: {}'.format(link.rel, link.href,
link.method))
print('Gross Amount: {} {}'.format(
response.result.purchase_units[0].amount.currency_code,
response.result.purchase_units[0].amount.value))
print(
float(total) == float(
response.result.purchase_units[0].amount.value))
if not address or not cart or not total:
return 5
if response.status_code != 200:
return 4
if float(total) != float(
response.result.purchase_units[0].amount.value):
return 1
if response.result.purchase_units[0].amount.currency_code != 'USD':
return 3
order = Order(address=address,
status='Order Confirmed',
total=total,
name=name,
user=user,
items=cart)
order.save()
return 0
def form_valid(self, form):
"""
Getting the request and then:
- get the order from paypal
- Get the request
"""
request = OrdersGetRequest(form.cleaned_data['order_id'])
# Call PayPal to get the transaction
response = self.client.execute(request)
# load the registration request id from the paypal order
self.kwargs[
'registration_request_id'] = response.result.purchase_units[
0].custom_id
# update the request status and add the order id
event_reg_request = RegistrationRequest.objects.get(
pk=self.kwargs['registration_request_id'])
event_reg_request.paypal_order_id = form.cleaned_data['order_id']
event_reg_request.status = COMPLETE
event_reg_request.save()
# Create the event registration for each of the events that the
# event_reg_request.eventregistrationitem is attached to.
# create an email message for each registration
email_connection = mail.get_connection()
# create the list of messages
email_messages = []
for event in event_reg_request.event_registration_item.events.all():
registration = Registration(
player=self.request.user.player,
event=event,
vehicle_make=event_reg_request.vehicle_make,
vehicle_model=event_reg_request.vehicle_model,
vehicle_color=event_reg_request.vehicle_color,
vehicle_registration=event_reg_request.vehicle_registration,
local_contact=event_reg_request.local_contact,
registration_request=event_reg_request)
registration.save()
# send an email to staff with a link to the registration
# send email using the self.cleaned_data dictionary
message = """
Hello!
{} {} has a new registration for event {}.
See it here:
{}
--ToV MechCrow
""".format(
self.request.user.first_name, self.request.user.last_name,
event.name,
self.request.build_absolute_uri(
reverse("registration:detail",
kwargs={'pk': registration.id})))
email_message = mail.EmailMessage(
"Registration for {} {}".format(self.request.user.first_name,
self.request.user.last_name),
message, settings.DEFAULT_FROM_EMAIL,
["*****@*****.**", "*****@*****.**"])
email_messages.append(email_message)
# send an email to each of them.
email_connection.send_messages(email_messages)
# close the connection to the email server
email_connection.close()
return super().form_valid(form)
def get_order(self, order_id):
request = OrdersGetRequest(order_id)
response = self.client.execute(request)
return response
def initGatewayByReturn(request):
# a get param named 'token' contains the order_id
paypalSettings = getPayPalSettings()
client = PayPalHttpClient(paypalSettings.environment)
donation_id = None
subscription_obj = {}
kwargs = {}
if request.GET.get('subscription_id', None):
# recurring payment
subscription_obj = getSubscriptionDetails(
request.session, request.GET.get('subscription_id'))
kwargs['subscription_obj'] = subscription_obj
if 'custom_id' in subscription_obj:
donation_id = subscription_obj['custom_id']
else:
raise ValueError(
_('Missing custom_id(donation_id) in curlPaypal-returned subscription'
))
elif request.GET.get('token', None):
# onetime payment
req = OrdersGetRequest(request.GET.get('token'))
# might throw IOError
response = client.execute(req)
_debug('PayPal: Returns from Gateway')
_debug('PayPal: Order status: ' + response.result.status)
donation_id = response.result.purchase_units[0].custom_id
kwargs['order_id'] = request.GET.get('token')
kwargs['order_status'] = response.result.status
if not donation_id:
raise ValueError(
_("Missing donation_id in purchase_units custom_id attribute"
))
else:
raise ValueError(_("Missing token from PayPal request"))
try:
donation = Donation.objects.get(pk=donation_id)
if request.GET.get('subscription_id', None):
# raise error if paypal_subscription_id already found in DonationPaymentMeta
dpm = DonationPaymentMeta.objects.filter(
donation=donation,
field_key='paypal_subscription_id',
field_value=request.GET.get('subscription_id'))
if len(dpm) >= 1:
raise ValueError(
_("PayPal subscription id found. Return request from PayPal is already invalid."
))
else:
dpm = DonationPaymentMeta(
donation=donation,
field_key='paypal_subscription_id',
field_value=request.GET.get('subscription_id'))
dpm.save()
elif request.GET.get('token', None):
# raise error if paypal_token already found in DonationPaymentMeta
dpm = DonationPaymentMeta.objects.filter(
donation=donation,
field_key='paypal_token',
field_value=request.GET.get('token'))
if len(dpm) >= 1:
raise ValueError(
_("PayPal token found. Return request from PayPal is already invalid."
))
else:
dpm = DonationPaymentMeta(
donation=donation,
field_key='paypal_token',
field_value=request.GET.get('token'))
dpm.save()
return Factory_Paypal.initGateway(request, donation, None,
**kwargs)
except Donation.DoesNotExist:
raise ValueError(
_("Donation object not found by id: ") + str(donation_id))
def GetOrder(order_id):
"""You can use this function to retrieve an order by passing order ID as an argument"""
"""Method to get order"""
request = OrdersGetRequest(order_id)
response = client.execute(request)
return response.result.__dict__["_dict"]
def pay(self, orderID, authorizationID, order):
orderTotal = order.get_total()
payPalOrder = OrdersGetRequest(orderID)
responseOrderDetails = self.client.execute(payPalOrder)
if ((float(responseOrderDetails.result.purchase_units[0].amount.value)
== orderTotal) &
(responseOrderDetails.result.purchase_units[0].amount.currency_code
== "USD")):
payPalCaptureRequest = AuthorizationsCaptureRequest(
authorizationID)
responsePayPalCapture = self.client.execute(payPalCaptureRequest)
status = responsePayPalCapture.status_code
if (status == 200) | (status == 201):
dabaBundle = {'status': 'Nice'}
order.ordered = True
try:
user_profile = UserProfile.objects.create(
user=order.user,
email=responseOrderDetails.result.payer.email_address,
provincia=responseOrderDetails.result.
purchase_units[0].shipping.address.admin_area_1,
canton=responseOrderDetails.result.purchase_units[0].
shipping.address.admin_area_2,
address=responseOrderDetails.result.purchase_units[0].
shipping.address.address_line_1,
distrito=responseOrderDetails.result.purchase_units[0].
shipping.address.address_line_2)
except AttributeError:
user_profile = UserProfile.objects.create(
user=order.user,
email=responseOrderDetails.result.payer.email_address,
provincia=responseOrderDetails.result.
purchase_units[0].shipping.address.admin_area_1,
canton=responseOrderDetails.result.purchase_units[0].
shipping.address.admin_area_2,
address=responseOrderDetails.result.purchase_units[0].
shipping.address.address_line_1)
order.user_profile = user_profile
order.save()
return JsonResponse({
"scc": "true",
"dataBundle": dabaBundle
},
status=200)
else:
dabaBundle = {'status': 'PaypalCaptureError'}
return JsonResponse({
"scc": "false",
"dataBundle": dabaBundle
},
status=400)
else:
voidRequest = AuthorizationsVoidRequest(authorizationID)
responsePayPalVoid = self.client.execute(voidRequest)
dabaBundle = {'status': 'AttemptedFraud'}
return JsonResponse({
"scc": "false",
"dataBundle": dabaBundle
},
status=400)
