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))