def err_execute_and_complete_payment(paypal_payment_id, paypal_payer_id):
""""Returns ERROR or None"""
# lock table tickets
db_session.execute('LOCK TABLES tickets WRITE, payments WRITE;')
payment = get_og_payment(paypal_payment_id)
if not payment:
return jsonify({'message': 'aucun paiement'}), 404
ticket = get_ticket_from_payment(payment)
err = get_err_from_ticket(ticket)
if err:
return err
prepare_payment_execution(payment, paypal_payer_id, ticket)
# Unlock tables (we do not want to lock while we query the paypal api)
db_session.execute('UNLOCK TABLES;')
# Validate payment is created
paypal_payment = PaypalPayment.find(paypal_payment_id)
if paypal_payment.state.lower() != 'created':
# TODO log status
print(paypal_payment)
return jsonify({'message': ERR_CREATE_PAYPAL}), 402
# Execute the payment
if (not paypal_payment.execute({"payer_id": paypal_payer_id})
or paypal_payment.state.lower() != 'approved'):
# Could not execute or execute did not approve transaction
return jsonify({'message': ERR_INVALID_PAYPAL}), 402
return complete_purchase(ticket)
def err_execute_and_complete_payment(paypal_payment_id, paypal_payer_id):
""""Returns ERROR or None"""
# lock table tickets
db_session.execute('LOCK TABLES tickets WRITE, payments WRITE;')
payment = get_og_payment(paypal_payment_id)
if not payment:
return jsonify({'message': 'aucun paiement'}), 404
ticket = get_ticket_from_payment(payment)
err = get_err_from_ticket(ticket)
if err:
return err
prepare_payment_execution(payment, paypal_payer_id, ticket)
# Unlock tables (we do not want to lock while we query the paypal api)
db_session.execute('UNLOCK TABLES;')
# Validate payment is created
paypal_payment = PaypalPayment.find(paypal_payment_id)
if paypal_payment.state.lower() != 'created':
# TODO log status
print(paypal_payment)
return jsonify({'message': ERR_CREATE_PAYPAL}), 402
# Execute the payment
if (not paypal_payment.execute({"payer_id": paypal_payer_id}) or
paypal_payment.state.lower() != 'approved'):
# Could not execute or execute did not approve transaction
return jsonify({'message': ERR_INVALID_PAYPAL}), 402
return complete_purchase(ticket)
def get(self, request):
payment_id = request.GET.get('paymentId')
payer_id = request.GET.get('PayerID')
paypalrestsdk.configure({
"mode": "sandbox", # sandbox or live
"client_id": "AWNIRUxctIc8ELjCrYLK8Zbv9L0EqL0aLplmLHpXPaPT_BVXINg66096i4jIO6i448h2fH-7sdaaiAtE",
"client_secret": "ECnA0hUuNZShemfJq5sD-UAfDUuEbr1i5j6RQcHdZJZiDkrYMTo1S6kA6E_OEwA_zX8FMEz4-57TfOaN"})
payment = Payment.find(payment_id)
print('aaaaaaaaaaaaaa')
import pdb; pdb.set_trace()
if payment.execute({'payer_id':payer_id}):
user_id = request.user
payment_id = payment.id
payer_id = payer_id
status = payment['state']
for pymt in payment['transactions']:
total_amount = pymt['amount']['total']
for amt in pymt['related_resources']:
subtotal = amt['sale']['amount']['details']['subtotal']
for itm in pymt['item_list']['items']:
fees_type = itm['name']
import pdb; pdb.set_trace()
user = FeesTransactionDetails.objects.create(student=user_id,amount=subtotal,payment_response=json.dumps(payment.to_dict()),status=status,payment_id=payment_id,payer_id=payer_id)
if user:
return HttpResponseRedirect(reverse('payment_success'))
else:
return HttpResponseRedirect(reverse('payment_wrong'))
def accept_paypal_payment(self, request, order_key=None):
try:
payer_id = request.GET['PayerID']
payment_id = request.GET['paymentId']
token = request.GET.get('token', None)
order_key = order_key
except KeyError:
return HttpResponseBadRequest('Bad request.')
else:
paypal_payment = PaypalPaymentSDK.find(payment_id, api=shopiepaypal)
if paypal_payment.execute({'payer_id': payer_id}):
# this will success
order = Order.objects.get(order_key=order_key)
self._create_payment(
order=order, token=token, payment_id=payment_id,
payer_id=payer_id
)
# because we want to give acccess to download "thing" as soon
# as customer pay the bill, and we just do that here. We will
# go ahead and accept this order.
order.accept()
return HttpResponseRedirect(self.get_thank_you_page(request))
else:
raise PaymentProcessingError(
"There was an error contacting the payment processor"
)
def post(self, request, *args, **kwargs):
"""
Place an order.
We fetch the txn details again and then proceed with oscar's standard
payment details view for placing the order.
"""
error_msg = _("A problem occurred communicating with PayPal "
"- please try again later")
try:
self.payer_id = request.POST['payer_id']
self.token = request.POST['token']
self.payment_id = request.POST['payment_id']
except KeyError:
# Probably suspicious manipulation if we get here
print("IS THIS THE SPOT OF ERROR???")
messages.error(self.request, error_msg)
return HttpResponseRedirect(reverse('basket:summary'))
try:
self.payment = Payment.find(self.payment_id)
#fetch_transaction_details(self.token)
except PayPalError:
# Unable to fetch txn details from PayPal - we have to bail out
messages.error(self.request, error_msg)
return HttpResponseRedirect(reverse('basket:summary'))
# Reload frozen basket which is specified in the URL
basket = self.load_frozen_basket(kwargs['basket_id'])
if not basket:
messages.error(self.request, error_msg)
return HttpResponseRedirect(reverse('basket:summary'))
submission = self.build_submission(basket=basket)
return self.submit(**submission)
def err_execute_and_complete_payment(paypal_payment_id, paypal_payer_id):
""""Returns ERROR or None"""
payment = get_og_payment(paypal_payment_id)
if not payment:
return jsonify({'message': 'aucun paiement'}), 404
ticket = get_ticket_from_payment(payment)
err = get_err_from_ticket(ticket)
if err:
return err
prepare_payment_execution(payment, paypal_payer_id, ticket)
# Validate payment is created
paypal_payment = PaypalPayment.find(paypal_payment_id)
if paypal_payment.state.lower() != 'created':
app.logger.critical('Possible tentative de fraude: "%s"' %
str(paypal_payment))
return jsonify({'message': ERR_CREATE_PAYPAL}), 402
# Execute the payment
if (not paypal_payment.execute({"payer_id": paypal_payer_id})
or paypal_payment.state.lower() != 'approved'):
# Could not execute or execute did not approve transaction
app.logger.critical('Possible tentative de fraude: "%s"' %
str(paypal_payment))
return jsonify({'message': ERR_INVALID_PAYPAL}), 402
return complete_purchase(ticket)
def payment_execute(request, template="shop/payment_confirmation.html"):
order = None
lookup = {}
if request.GET.has_key('token'):
paypal_api()
token = request.GET['token']
payer_id = request.GET['PayerID']
order = get_object_or_404(Order, paypal_redirect_token=token)
payment = Payment.find(order.transaction_id)
payment.execute({"payer_id": payer_id})
elif request.GET.has_key('transaction_id'):
api = pagseguro_api()
email = api.data['email']
token = api.data['token']
transaction = request.GET['transaction_id']
url = api.config.TRANSACTION_URL % transaction
resp = urllib2.urlopen("%s?email=%s&token=%s" %
(url, email, token)).read()
lookup["id"] = ETree.fromstring(resp).findall("reference")[0].text
print ETree.fromstring(resp).findall("reference")[0].text
if not request.user.is_authenticated():
lookup["key"] = request.session.session_key
if not request.user.is_staff: lookup["user_id"] = request.user.id
order = get_object_or_404(Order, **lookup)
order.transaction_id = transaction
elif request.GET.has_key('orderid'):
return redirect("/store/bank?order_id=%s" % request.GET['orderid'])
order.status = 2
order.save()
context = {"order": order}
response = render(request, template, context)
return response
def finish_payment(bot, trigger):
api = create_api(bot.config.donabot)
payment_id = trigger.group(1)
bot.msg(trigger.nick, "Hold on, checking your payment...")
try:
payment = Payment.find(payment_id, api=api)
except ResourceNotFound:
payment = None
if payment is not None:
payer_id = payment["payer"]["payer_info"]["payer_id"]
result = payment.execute({"payer_id": payer_id})
if result is True:
amount = float(payment["transactions"][0]["amount"]["total"])
currency = payment["transactions"][0]["amount"]["currency"]
channel = bot.config.donabot.channel
bot.write(("MODE", channel, "+v", trigger.nick))
bot.msg(
channel,
"*** {} just donated {:.2f} {}!".format(trigger.nick, amount, currency)
)
bot.msg(trigger.nick, "Thank you for your support!")
else:
bot.msg(trigger.nick, "Unable to execute the payment. :-(")
else:
bot.msg(trigger.nick, "I'm sorry, but I can't find your payment. :-(")
def payment_execute(request, template="shop/payment_confirmation.html"):
order = None
lookup = {}
if request.GET.has_key('token'):
paypal_api()
token = request.GET['token']
payer_id = request.GET['PayerID']
order = get_object_or_404(Order, paypal_redirect_token=token)
payment = Payment.find(order.transaction_id)
payment.execute({ "payer_id": payer_id })
elif request.GET.has_key('transaction_id'):
api = pagseguro_api()
email = api.data['email']
token = api.data['token']
transaction = request.GET['transaction_id']
url = api.config.TRANSACTION_URL % transaction
resp = urllib2.urlopen("%s?email=%s&token=%s" % (url,email,token)).read()
lookup["id"] = ETree.fromstring(resp).findall("reference")[0].text
print ETree.fromstring(resp).findall("reference")[0].text
if not request.user.is_authenticated(): lookup["key"] = request.session.session_key
if not request.user.is_staff: lookup["user_id"] = request.user.id
order = get_object_or_404(Order, **lookup)
order.transaction_id = transaction
elif request.GET.has_key('orderid'):
return redirect("/store/bank?order_id=%s" % request.GET['orderid'])
order.status = 2
order.save()
context = { "order" : order }
response = render(request, template, context)
return response
def ride_booking_execute_payment(payer_id, ride_booking):
payment = Payment.find(ride_booking.paypal_payment_id)
if ride_booking.status == RideBookingStatus.CREATED:
if payment.execute({"payer_id": payer_id}):
ride_booking.status = RideBookingStatus.PAYED
ride_booking.save()
ride = ride_booking.ride
send_mail(
'email_passenger_ride_booking_payed',
[ride_booking.client.email], {
'ride': ride,
'ride_detail':
settings.RIDE_DETAIL_URL.format(ride_pk=ride.pk)
})
send_mail(
'email_driver_ride_booking_payed',
[ride_booking.ride.car.owner.email], {
'ride': ride,
'ride_detail':
settings.RIDE_DETAIL_URL.format(ride_pk=ride.pk)
})
if ride_booking.ride.car.owner.sms_notifications:
send_sms(
'sms_driver_ride_booking_payed',
[ride_booking.ride.car.owner.normalized_phone], {
'ride':
ride,
'ride_detail':
settings.RIDE_DETAIL_URL.format(ride_pk=ride.pk)
})
return True
return False
def get_payment(payment_id, paypal_mode, paypal_client_id,
paypal_client_secret):
return Payment.find(resource_id=payment_id,
api=Api({
'mode': paypal_mode,
'client_id': paypal_client_id,
'client_secret': paypal_client_secret
}))
def get(self, request, *args, **kwargs):
paypalrestsdk.configure({
"mode": "sandbox",
"client_id": settings.PAYPAL_CLIENT_ID,
"client_secret": settings.PAYPAL_CLIENT_SECRET
})
"""
Fetch details about the successful transaction from PayPal. We use
these details to show a preview of the order with a 'submit' button to
place it.
"""
try:
print("GET: SuccessResponseView - views.py: can you see me?")
self.payer_id = request.GET['PayerID']
self.token = request.GET['token']
self.payment_id = request.GET['paymentId']
except KeyError:
# Manipulation - redirect to basket page with warning message
logger.warning("Missing GET params on success response page")
messages.error(self.request,
_("Unable to determine PayPal transaction details"))
return HttpResponseRedirect(reverse('basket:summary'))
try:
# self.txn = fetch_transaction_details(self.token)
print("TOKEN:")
print(self.token)
print("END TOKEN")
self.payment = Payment.find(self.payment_id)
print("PAYMENT:")
print(self.payment)
print("END PAYMENT")
except PayPalError as e:
logger.warning(
"Unable to fetch transaction details for token %s: %s",
self.token, e)
messages.error(
self.request,
_("A problem occurred communicating with PayPal - please try again later"
))
return HttpResponseRedirect(reverse('basket:summary'))
# Reload frozen basket which is specified in the URL
kwargs['basket'] = self.load_frozen_basket(kwargs['basket_id'])
if not kwargs['basket']:
logger.warning("Unable to load frozen basket with ID %s",
kwargs['basket_id'])
messages.error(
self.request,
_("No basket was found that corresponds to your "
"PayPal transaction"))
return HttpResponseRedirect(reverse('basket:summary'))
logger.info(
"Basket #%s - showing preview with payer ID %s and token %s",
kwargs['basket'].id, self.payer_id, self.token)
return super(SuccessResponseView, self).get(request, *args, **kwargs)
def payment_execute(payment_id, payer_id, token):
logging.basicConfig(level=logging.INFO)
payment = Payment.find(payment_id)
if payment.execute({"payer_id": payer_id}): # return True or False
print("Paypal -- Payment[%s] execute successfully" % (payment.id))
# for paypal payment return
return {'payment_id': payment.id, 'payment_state': payment.state}
else:
print(payment.error)
def execute_payment(paymentid, userid):
# ID of the payment. This ID is provided when creating payment.
payment = Payment.find(paymentid)
# PayerID is required to approve the payment.
if payment.execute({"payer_id": userid}):
logging.info("Payment[%s] execute successfully"%(paymentid))
else:
logging.error(payment.error)
def process(self):
configure_paypal()
# Payment id obtained when creating the payment (following redirect)
payment = Payment.find(self.cleaned_data['paymentId'])
# Execute payment using payer_id obtained when creating the payment (following redirect)
executed = payment.execute({"payer_id": self.cleaned_data['PayerID']})
return executed, payment
def execute_payment(self, payment_id, payer_id='DUFRQ8GWYMJXC'):
# ID of the payment. This ID is provided when creating payment.
payment = Payment.find(payment_id)
# PayerID is required to approve the payment.
if payment.execute({"payer_id": payer_id}): # return True or False
print("Payment[%s] execute successfully" % (payment.id))
else:
print(payment.error)
def get_payment_url(paypal_id):
configure_paypal()
payment = Payment.find(paypal_id)
print(paypal_id)
for link in payment.links:
if link.rel == "approval_url":
# Convert to str to avoid Google App Engine Unicode issue
# https://github.com/paypal/rest-api-sdk-python/pull/58
approval_url = str(link.href)
return approval_url
return None
def execute_payment_process(payment_id, payer_id):
# Payment ID obtained when creating the payment (following redirect)
payment = Payment.find(payment_id)
# Execute payment with the payer ID from the create payment call (following redirect)
if payment.execute({"payer_id": payer_id}):
print("Payment[%s] execute successfully" % (payment.id))
return {"payment": payment.id}
else:
print(payment.error)
return {"error": payment.error}
def execute_payment(raw_payment, payer_id):
raw_payment = json.loads(raw_payment)
payment_id = raw_payment.get('id')
if payment_id is None or payer_id is None:
return None
payment = Payment.find(payment_id)
if not payment.execute({
'payer_id': payer_id,
}):
return None
return payment
def execute(id):
payment = Payment.find(request.args.get('paymentId'))
order = Order.query.get(id)
if not order or order.buyer != current_user:
flash('Your order was not found, maybe it was already cancelled?')
return redirect(url_for('shop'))
if order.paid:
flash('Your order was already paid, not charging you twice!')
return redirect(url_for('shop'))
if order.payment_id != payment.id:
flash('This payment does not seem to match your order!')
return redirect(url_for('shop'))
if not payment.execute(dict(payer_id=request.args.get('PayerID'))):
flash('An error occured while processing your order: {}'.format(
payment.error))
return redirect(url_for('shop'))
order.paid = True
order.item.quantity -= 1
db.session.commit()
message = Message(
html=render_template(
'order_receipt.html',
order=order,
item=order.item,
user=order.buyer,
),
subject='Receipt for your purchase - {}'.format(
app.config['SITE_NAME']),
mail_from=(
app.config['SITE_NAME'],
'noreply@%s' % app.config['SUPPORT_EMAIL'].split('@')[1],
),
)
user = order.buyer
response = message.send(to=(
'{} {}'.format(user.first_name, user.last_name),
user.email,
))
flash('Your order was processed successfully{}. Thank you!'.format(
'' if response.status_code == 250 else (
', but your purchase receipt could not be sent. '
'Contact us at {} in order to get your receipt.'
).format(app.config['SUPPORT_EMAIL'])))
return redirect(url_for('shop'))
def execute_payment(payment_id, payer_id):
"""
paypal执行付款
payment_id: 账单ID
payer_id: 客户ID
"""
payment = Payment.find(payment_id)
if payment.execute({"payer_id": payer_id}):
log.info('[payment] paypal payment %s execute success', payment.id)
return payment
else:
log.error('[payment] paypal payment execute fail, %s', payment.error)
return None
def class_view(cls, request: HttpRequest):
payment_id = request.GET.get('paymentId')
payer_id = request.GET.get('PayerID')
if not payment_id:
raise SuspiciousOperation
payment = PaymentMethod(payment_id)
paypal = Payment.find(payment_id)
if not paypal.execute({'payer_id': payer_id}):
raise ValueError('PayPal did not complete pmt %s' % payment_id)
payment.callback_view(paypal)
# This is actually the user here, not a callback bot! So we must return to base.
# TODO: What if the user never returns home after paying? Should we poll pending transactions?
return prg_redirect(payment.my_view_url(request))
def payment_execute(self, request, template="shop/payment_confirmation.html"):
paypal_api()
token = request.GET['token']
payer_id = request.GET['PayerID']
logger.debug("feedly.views.payment_execute(token=%s,payer_id=%s)" % (token,payer_id))
order = get_object_or_404(Order, paypal_redirect_token=token)
payment = Payment.find(order.transaction_id)
payment.execute({ "payer_id": payer_id })
# Pago, falta enviar
order.status = 3
order.save()
context = { "order" : order }
response = render(request, template, context)
return response
def ride_booking_refund(ride_booking):
refund_total = ride_booking.ride.price_with_fee * \
ride_booking.seats_count
payment = Payment.find(ride_booking.paypal_payment_id)
sale_id = payment.transactions[0].related_resources[0]['sale'].id
sale = Sale.find(sale_id)
refund = sale.refund({
"amount": {
"total": '{0:.2f}'.format(refund_total),
"currency": "USD"
}
})
if not refund.success():
raise Exception("Cannot create a refund:\n{0}".format(refund.error))
def finalize_payment(request, order):
if request.GET.get('paymentId'): #from paypal redirect
payment = Payment.find(request.GET.get('paymentId'))
if payment.execute({'payer_id': request.GET.get('PayerID')}):
order.charge_id = payment.transactions[0].related_resources[
0].sale.id
order.paid = True
order.save()
order_items = Cart_Item.objects.filter(owner=request.user)
for item in order_items:
product = item.product
product.stock -= item.quantity
product.save()
item.delete()
email_context = {'order': order}
subject = '###### -- Order Confirmation ' + order.ref_code
html_msg = render_to_string('emails/order_confirmation.html',
context=email_context)
plain_msg = strip_tags(html_msg)
mail.send_mail(subject,
plain_msg,
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[order.owner.email],
fail_silently=False,
html_message=html_msg)
html_msg = render_to_string('emails/order_confirmation_staff.html',
context=email_context)
plain_msg = strip_tags(html_msg)
staff_subject = '[######] Order Received - ' + order.ref_code
mail.send_mail(staff_subject,
plain_msg,
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=['######@###.com'],
fail_silently=False,
html_message=html_msg)
pass
def success():
# TODO: set donation to success
if 'paymentId' in request.args and 'PayerID' in request.args:
try:
payment = Payment.find(request.args['paymentId']) # type: Payment
payment.execute({'payer_id': request.args['PayerID']})
donation = Donation.objects(
paypal_payment_id=request.args['paymentId']).first(
) # type: Donation
if donation is not None:
donation.project.current_budget += donation.amount
donation.status = str(Donation.Status.SUCCESS)
donation.project.save()
donation.save()
# redirected to frontend again
return redirect('http://localhost:3000/donation/success')
except ResourceNotFound:
return redirect('http://localhost:3000/donation/failed')
else:
return jsonify({'message': 'No payment details given'}), 422
def execute_payment(request):
print request.build_absolute_uri()
PayerID = request.GET['PayerID']
print PayerID
print payment_dict
# ID of the payment. This ID is provided when creating payment.
if ('payment_id',request.user.id) in payment_dict:
payment = Payment.find(payment_dict[('payment_id',request.user.id)][0])
else:
return HttpResponseRedirect("/home?paypal_error=true")
if not payment_dict[('payment_id',request.user.id)][1]:
# PayerID is required to approve the payment.
if payment.execute({"payer_id": PayerID}): # return True or False
print("Payment[%s] execute successfully"%(payment.id))
payment_dict[('payment_id',request.user.id)][1] = False
create_swap_with_money(18539,0.00,6.00,request)
return HttpResponseRedirect('/paypal_trasaction_success')
else:
print(payment.error)
return HttpResponseRedirect("/home?paypal_error=true")
def paypal_execute(request, template="shop/payment_confirmation.html"):
"""
Recebe a confirmação de pagamento do paypal
"""
token = request.GET['token']
payer_id = request.GET['PayerID']
logger.debug("integration.views.paypal_execute(token=%s,payer_id=%s)" %
(token, payer_id))
order = get_object_or_404(Order, paypal_redirect_token=token)
payment = Payment.find(order.transaction_id)
payment.execute({"payer_id": payer_id})
# Pago, falta enviar
order.status = 3
order.save()
context = {"order": order}
response = render(request, template, context)
return response
def on_return(self, request):
from paypalrestsdk import Payment
params = self.settings
payment_id = request.GET.get('paymentId')
payment = Payment.find(payment_id)
payer_id = request.GET.get('PayerID')
self.payment.customer_id = payer_id
if payment.execute({"payer_id": payer_id}):
self.payment.status = PaymentStatus.CONFIRMED
print("Payment[%s] execute successfully" % (payment.id))
elif self.payment.status != PaymentStatus.CONFIRMED:
self.payment.status = PaymentStatus.ERROR
print(payment.error)
# TODO FIX IT
# self.payment.log_data('payment_respond', self.payment.status, payment)
try:
self.payment.save()
except:
pass
# import ipdb; ipdb.set_trace()
return render(request, "payments/status.html",
dict(payment=self.payment))
def get(self, request, *args, **kwargs):
try:
self.payment_id = request.GET['paymentId']
self.payer_id = request.GET['PayerID']
self.token = request.GET['token']
except:
# Manipulation - redirect to basket page with warning message
logger.warning("Missing GET params on success response page")
messages.error(self.request,
_("Unable to determine PayPal transaction details"))
return HttpResponseRedirect(reverse("basket:summary"))
basket = request.basket
if not basket:
return http.HttpResponseBadRequest()
self.paypal_approved = True
self.payment = Payment.find(self.payment_id)
return self.handle_place_order_submission(request)
# Execute an approved PayPal payment
# Use this call to execute (complete) a PayPal payment that has been approved by the payer.
# You can optionally update transaction information by passing in one or more transactions.
# API used: /v1/payments/payment
from paypalrestsdk import Payment
import logging
logging.basicConfig(level=logging.INFO)
# ID of the payment. This ID is provided when creating payment.
payment = Payment.find("PAY-28103131SP722473WKFD7VGQ")
# PayerID is required to approve the payment.
if payment.execute({"payer_id": "DUFRQ8GWYMJXC"}): # return True or False
print("Payment[%s] execute successfully" % (payment.id))
else:
print(payment.error)
from paypalrestsdk import Payment
import logging
logging.basicConfig(level=logging.INFO)
payment = Payment.find("<PAYMENT_ID>")
# e.g. Update shipping amount in the transactions array after payment creation
# and calling payment execute
# https://developer.paypal.com/webapps/developer/docs/api/#transaction-object
execute_payment_json = {
"payer_id": "HCXTE7DLHVTDN",
"transactions": [{
"amount": {
"total": "35.07",
"currency": "USD",
"details": {
"subtotal": "30.00",
"tax": "0.07",
"shipping": "2.00",
"handling_fee": "1.00",
"shipping_discount": "1.00",
"insurance": "1.00"
}
}
}]
};
if payment.execute(execute_payment_json): # return True or False
print("Payment[%s] execute successfully"%(payment.id))
else:
def getPayment(self):
return Payment.find(self.paymentId)
def find_paypal_payment(payment_id):
try:
payment = Payment.find(payment_id)
except ResourceNotFound as error:
payment = None
return payment
# GetPayment Sample
# This sample code demonstrates how you can retrieve
# the details of a payment resource.
# API used: /v1/payments/payment/{payment-id}
from paypalrestsdk import Payment, ResourceNotFound
import logging
logging.basicConfig(level=logging.INFO)
try:
# Retrieve the payment object by calling the
# `find` method
# on the Payment class by passing Payment ID
payment = Payment.find("PAY-0XL713371A312273YKE2GCNI")
print("Got Payment Details for Payment[%s]" % (payment.id))
except ResourceNotFound as error:
# It will through ResourceNotFound exception if the payment not found
print("Payment Not Found")
def post(self, request):
paymentID = request.data['paymentID']
payerID = request.data['payerID']
payment = Payment.find(paymentID)
if not payment['payer']['status'] == 'VERIFIED':
return Response(data={
"success": False,
"error": "The paypal account is not verified.",
"not_verified": True,
},
status=status.HTTP_400_BAD_REQUEST)
custom = payment['transactions'][0]['custom']
item_id = payment['transactions'][0]['item_list']['items'][0]['sku']
email = payment['payer']['payer_info']['email']
user_id, start_date, end_date, request_slug = custom.split(',')
start_date = parse_datetime(start_date)
end_date = parse_datetime(end_date)
try:
item = Item.objects.get(pk=item_id)
except:
return Response({"error": "item in custom field not found"},
status=status.HTTP_400_BAD_REQUEST)
# success, message = item.test_lockout_range(start_date, end_date);
# if not success:
# return Response({"error": message}, status=status.HTTP_400_BAD_REQUEST)
try:
user = User.objects.get(pk=user_id)
except:
return Response({"error": "user not found"},
status=status.HTTP_400_BAD_REQUEST)
if payment.execute({"payer_id": payerID}):
# save paypal account in user profile
user.profile.paypal_email = email
user.profile.is_verified = True
user.profile.save()
# TODO: Maybe? save history of all paypal accounts a user has used. Helps prevent fraud
# in case someone uses a stolen account we have a history of it.
success, transaction_details = create_transaction(
paymentID=paymentID,
borrower=request.user,
borrowRequestSlug=request_slug)
if success:
return Response(data={
"success": True,
"transaction": transaction_details
},
status=status.HTTP_201_CREATED)
else:
return Response(data={
"success":
True,
"error":
transaction_details,
"message":
"Payment executed but error in creating Transaction Model",
"details for create_transaction":
transaction_details
},
status=status.HTTP_400_BAD_REQUEST)
# return Response({"success": True, "paymentID": payment.id})
else:
return Response(data={
"success": False,
"error": "PayPal payment execute failed."
},
status=status.HTTP_400_BAD_REQUEST)
logger.error(payment.error) # Error Hash
def paypal_payment():
try:
userid = int(request.json['userid'])
pay_id = request.json['payid']
print(pay_id)
payment = Payment.find(pay_id)
print(payment)
transactions = []
transaction_amount = {}
# credit_card = {}
sales_id = 0
soj_transaction_id = 0
transactionstatus = ""
# for card_details in payment.payer.funding_instruments:
# if card_details.has_key('credit_card_token'):
# credit_card = {"expire_year":card_details.credit_card_token.expire_year,
# "type":card_details.credit_card_token.type,"number":card_details.credit_card_token.number,
# "expire_month":card_details.credit_card_token.expire_month}
# elif card_details.has_key('credit_card'):
# credit_card = {"expire_year":card_details.credit_card.expire_year,
# "type":card_details.credit_card.type,"number":card_details.credit_card.number,
# "expire_month":card_details.credit_card.expire_month}
# transactions.append(credit_card)
for transaction_details in payment.transactions:
transaction_amount = {"currency": transaction_details.amount.currency,
"total": transaction_details.amount.total}
sales_link = transaction_details['related_resources'][0]['sale']['links'][0]['href']
sales_list = sales_link.split('sale')[1]
sales_id = sales_list.split('/')[1]
soj_transaction_id = int(transaction_details.description)
transactionstatus = int(request.json['transactionid'])
transactions.append(transaction_amount)
payment_details = {"payment": payment.id, "sales_id": sales_id, "paymenttype": payment.payer.payment_method,
"state": payment.state, "transaction_details": transactions}
if payment.state == "approved":
print(soj_transaction_id)
TransactionTrack.update({
"transactionid": soj_transaction_id
}, {
"$set": {
"transactionstatus": transactionstatus,
"transactionresponse": payment_details,
"responsedatetime": datetime.datetime.now()
}
})
transactions_details_from_database = TransactionTrack.find_one({"transactionid": soj_transaction_id},
{"_id": 0})
print(transactions_details_from_database)
bidid = transactions_details_from_database['jobbid']
jobid = transactions_details_from_database['jobid']
final_bid = JobBids.find_one({"bidid": int(bidid)}, {"_id": 0})
completionremarks = ""
# completionstatus = ""
bidcanceldatetime = ""
bidcancellationreason = ""
# bidselected = False
jobberfullname = ""
# jobberEmail = None
# jobberMobile = None
bidderfullname = ""
bidder_email = None
# bidderMobile = None
person_selected = 0
if final_bid is not None:
job_collection = Jobs.find_one({"jobid": final_bid['jobid']}, {"_id": 0})
if job_collection:
try:
person_selected = int(job_collection['personsselected'])
except ValueError:
pass
user_jobber_collection = User.find_one({"userid": job_collection['creatinguserid']}, {"_id": 0})
if user_jobber_collection is not None:
jobberfullname = user_jobber_collection['firstname'] + " " + user_jobber_collection['lastname']
# jobberEmail = user_jobber_collection['email']
# jobberMobile = user_jobber_collection['mobile']
user_bidder_collection = User.find_one({"userid": final_bid['userid']}, {"_id": 0})
if user_bidder_collection is not None:
bidderfullname = user_bidder_collection['firstname'] + " " + user_bidder_collection['lastname']
bidder_email = user_bidder_collection['email']
# bidderMobile = user_bidder_collection['mobile']
else:
print("No jobs")
if request.json['status'] == "selectedbyjobber":
if final_bid['status'] == "pending":
print(transaction_amount)
JobBids.update({
"bidid": int(bidid)
}, {
"$set": {
"selected": True,
"final_bidamount": int(float(transaction_amount['total'])),
"bidcanceldatetime": bidcanceldatetime,
"bidcancellationreason": bidcancellationreason,
"status": "selectedbyjobber",
"completionstatus": "pending",
"completionremarks": completionremarks
}
})
if job_collection['personsrequired'] > person_selected:
if job_collection['personsrequired'] == person_selected + 1:
Jobs.update({"jobid": int(jobid)}, {"$set": {
"personsselected": int(person_selected + 1),
"jobstatus": "allotted"
}})
else:
Jobs.update({"jobid": int(jobid)}, {"$set": {
"personsselected": int(person_selected + 1)
}})
# Ledger Entries
Ledgers.bid_selection_entries(userid, jobid, bidid, final_bid, payment_details)
# Push Notification Bid Accepted
PushNotificationUtils.notify_bid_accepted(userid, jobid, bidid, job_collection, jobberfullname,
final_bid)
# Bid Accepted Email
EmailUtils.send_bid_accpeted_mail(final_bid['userid'], bidder_email, job_collection['title'],
bidderfullname, jobberfullname, transaction_amount['total'])
elif request.json['status'] == "reversebid":
job_bid_detail = JobBids.find_one({"bidid": int(bidid)}, {"_id": 0})
if job_bid_detail is not None:
if job_bid_detail['status'] == 'pending':
total_bid_amount = int(float(transaction_amount['total']))
# updating bidamount array and reverse bid array
reverse_bid_data = {"reversebidamount": int(float(transaction_amount['total'])),
"reversebiddatetime": datetime.datetime.now()}
JobBids.update({"bidid": int(bidid)}, {"$set": {"status": "reversebid",
"reversebid": reverse_bid_data,
"final_bidamount": total_bid_amount
}})
# Bid Reverse Entried
Ledgers.bid_reverse_entries(userid, jobid, bidid, final_bid, payment_details)
# Bid Reverse Push Notification
PushNotificationUtils.notify_bid_reverse(userid, jobid, bidid, job_collection,
bidderfullname, job_bid_detail)
# Bid Reverse Email
EmailUtils.send_reverse_bid_mail(final_bid['userid'], bidder_email, job_collection['title'],
bidderfullname, jobberfullname,
transaction_amount['total'])
return make_response(jsonify({"status": 200, "message": "Payment Successful"}), 200)
except ResourceNotFound as e:
print("Payment Not Found")
print(str(e))
return make_response(jsonify({"status": 500, "message": "Something went wrong, Please try again!"}), 500)
except Exception as e:
print(str(e))
return make_response(jsonify({"status": 500, "message": "Something went wrong, Please try again!"}), 500)
def create_transaction(*,
paymentID=None,
borrower=None,
borrowRequestSlug=None):
try:
payment = Payment.find(paymentID)
except ResourceNotFound:
return False, "Wrong PayPal Payment code. Payment not found."
except ServerError:
# Save to another model for later attempting.
failed_transaction = TransactionFailedToCreate(
borrower=borrower, paypal_payment_id=paymentID)
failed_transaction.save()
return False, "Internal Server Error on PayPal's behalf."
payment_details = payment.to_dict()
if not payment_details['transactions']:
# raise ValueError("PayPal error: No transaction found.")
return False, "Paypal error: No transaction found"
if not payment_details['transactions'][0]['item_list']['items']:
return False, "PayPal error: No items found as part of that transaction."
item_details = payment_details['transactions'][0]['item_list']['items'][0]
item_id = item_details['sku']
try:
item = Item.objects.get(id=item_id)
except Item.DoesNotExist:
return False, "Item not found"
try:
borrower = User.objects.get(pk=borrower.id)
except:
return False, "Borrower not found"
try:
custom_field = payment_details['transactions'][0]['custom']
try:
paypal_payee_id, start_date, end_date, request_slug = custom_field.split(
',')
start_date = parse_datetime(start_date)
end_date = parse_datetime(end_date)
except:
return False, "Paypal Custom Field if not of format User,Start,End,RequestSlug."
try:
paypal_payee = User.objects.get(pk=paypal_payee_id)
except:
return False, "Paypal payee id not found."
if not paypal_payee == borrower:
# print('borrower is not person who paid for paypal transaction')
return False, "User is not payer in paypal transaction"
except:
# print("paypal payee id not found. Check for 'custom' field in transaction")
return False, "Custom Field not working."
try:
borrow_request = BorrowRequest.objects.get(slug=request_slug)
except BorrowRequest.DoesNotExist:
return False, 'Borrow Request not found'
try:
transaction = Transaction.objects.get(payment_id=paymentID)
return False, 'Transaction already exists'
except Transaction.DoesNotExist:
borrow_request.paid = True
borrow_request.save()
transaction = Transaction(
lender=item.user,
borrower=borrower,
item=item,
payment_id=payment.id,
date_used_start=start_date,
date_used_end=end_date,
days_borrowed=item_details['quantity'],
total_price=payment_details['transactions'][0]['amount']['total'],
borrow_request=borrow_request)
transaction.save()
serializer = TransactionSerializer(transaction)
send_fcm_message(recipient=borrow_request.lender,
title="Payment Received!",
body="%s has paid for %s" %
(borrow_request.borrower.username, item.title),
tag="REQUEST UPDATE")
send_request_paid_email(recipient=item.user,
sender=borrower,
item_name=item.title)
return True, serializer.data
def getPayment(self):
return Payment.find(self.paymentId)
from paypalrestsdk import Payment
import logging
logging.basicConfig(level=logging.INFO)
payment = Payment.find("<PAYMENT_ID>")
# e.g. Update shipping amount in the transactions array after payment creation
# and calling payment execute
# https://developer.paypal.com/webapps/developer/docs/api/#transaction-object
execute_payment_json = {
"payer_id":
"HCXTE7DLHVTDN",
"transactions": [{
"amount": {
"total": "35.07",
"currency": "USD",
"details": {
"subtotal": "30.00",
"tax": "0.07",
"shipping": "2.00",
"handling_fee": "1.00",
"shipping_discount": "1.00",
"insurance": "1.00"
}
}
}]
}
if payment.execute(execute_payment_json): # return True or False
print("Payment[%s] execute successfully" % (payment.id))
