def execute_payment(self, request: HttpRequest, payment: OrderPayment) -> str: # This method will only be called when retrying payments, e.g. after a payment_prepare call. It is not called # during the order creation phase because this payment provider is a special case. for p in payment.order.positions.all(): # noqa - just a safeguard if p.item.issue_giftcard: raise PaymentException( _("You cannot pay with gift cards when buying a gift card." )) gcpk = payment.info_data.get('gift_card') if not gcpk or not payment.info_data.get('retry'): raise PaymentException("Invalid state, should never occur.") with transaction.atomic(): gc = GiftCard.objects.select_for_update().get(pk=gcpk) if gc.currency != self.event.currency: # noqa - just a safeguard raise PaymentException( _("This gift card does not support this currency.")) if not gc.accepted_by( self.event.organizer): # noqa - just a safeguard raise PaymentException( _("This gift card is not accepted by this event organizer." )) if payment.amount > gc.value: # noqa - just a safeguard raise PaymentException( _("This gift card was used in the meantime. Please try again" )) trans = gc.transactions.create(value=-1 * payment.amount, order=payment.order, payment=payment) payment.info_data = { 'gift_card': gc.pk, 'transaction_id': trans.pk, } payment.confirm()
def execute_payment(self, request: HttpRequest, payment: OrderPayment): request.session['payment_bitpay_order_secret'] = payment.order.secret try: inv = self.client.create_invoice({ "price": float(payment.amount), "currency": self.event.currency, "orderId": payment.order.full_code, "transactionSpeed": "medium", "extendedNotifications": "true", "notificationURL": build_absolute_uri(self.event, "plugins:pretix_bitpay:webhook"), "redirectURL": build_absolute_uri(self.event, "plugins:pretix_bitpay:return", kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(), }), # "buyer": {"email": "*****@*****.**"}, "token": self.settings.token }) except (BitPayConnectionError, BitPayBitPayError, BitPayArgumentError) as e: logger.exception('Failure during bitpay payment.') raise PaymentException(_('We had trouble communicating with BitPay. Please try again and get in touch ' 'with us if this problem persists.')) ReferencedBitPayObject.objects.get_or_create(order=payment.order, payment=payment, reference=inv['id']) payment.info = json.dumps(inv) payment.save(update_fields=['info']) return self.redirect(request, inv['url'])
def shred_payment_info(self, obj: OrderPayment): if not obj.info: return d = json.loads(obj.info) if 'details' in d: d['details'] = {k: '█' for k in d['details'].keys()} d['_shredded'] = True obj.info = json.dumps(d) obj.save(update_fields=['info'])
def execute_payment(self, request: HttpRequest, payment: OrderPayment): try: req = self._post('Payment/v1/PaymentPage/Initialize', json=self._get_payment_page_init_body(payment)) req.raise_for_status() except HTTPError: logger.exception('Saferpay error: %s' % req.text) try: payment.info_data = req.json() except: payment.info_data = {'error': True, 'detail': req.text} payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action( 'pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'data': payment.info_data }) raise PaymentException( _('We had trouble communicating with Saferpay. Please try again and get in touch ' 'with us if this problem persists.')) data = req.json() payment.info = json.dumps(data) payment.state = OrderPayment.PAYMENT_STATE_CREATED payment.save() request.session['payment_saferpay_order_secret'] = payment.order.secret return self.redirect(request, data.get('RedirectUrl'))
def execute_payment(self, request: HttpRequest, payment: OrderPayment): try: req = requests.post('https://api.mollie.com/v2/payments', json=self._get_payment_body(payment), headers=self.request_headers) req.raise_for_status() except HTTPError: logger.exception('Mollie error: %s' % req.text) try: payment.info_data = req.json() except: payment.info_data = {'error': True, 'detail': req.text} payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action( 'pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'data': payment.info_data }) raise PaymentException( _('We had trouble communicating with Mollie. Please try again and get in touch ' 'with us if this problem persists.')) data = req.json() payment.info = json.dumps(data) payment.state = OrderPayment.PAYMENT_STATE_CREATED payment.save() request.session['payment_mollie_order_secret'] = payment.order.secret return self.redirect(request, data.get('_links').get('checkout').get('href'))
def execute_payment(self, request: HttpRequest, payment: OrderPayment): request.session['sofort_order_secret'] = payment.order.secret shash = hashlib.sha1(payment.order.secret.lower().encode()).hexdigest() r = sofort.MultiPay( project_id=self.settings.get('project_id'), amount=payment.amount, currency_code=self.event.currency, reasons=[payment.order.full_code, '-TRANSACTION-'], user_variables=[payment.order.full_code], success_url=build_absolute_uri(self.event, 'plugins:pretix_sofort:return', kwargs={ 'order': payment.order.code, 'hash': shash, }) + '?state=success&transaction=-TRANSACTION-', abort_url=build_absolute_uri(self.event, 'plugins:pretix_sofort:return', kwargs={ 'order': payment.order.code, 'hash': shash, }) + '?state=abort&transaction=-TRANSACTION-', timeout_url=build_absolute_uri(self.event, 'plugins:pretix_sofort:return', kwargs={ 'order': payment.order.code, 'hash': shash, }) + '?state=timeout&transaction=-TRANSACTION-', notification_urls=[ build_absolute_uri(self.event, 'plugins:pretix_sofort:webhook') ], ) try: trans = sofort.NewTransaction.from_xml(self._api_call(r.to_xml())) except sofort.SofortError as e: logger.exception('Failure during sofort payment: {}'.format( e.message)) raise PaymentException( _('Sofort reported an error: {}').format(e.message)) except IOError: logger.exception('Failure during sofort payment.') raise PaymentException( _('We had trouble communicating with Sofort. Please try again and get in touch ' 'with us if this problem persists.')) ReferencedSofortTransaction.objects.get_or_create( order=payment.order, reference=trans.transaction, payment=payment) payment.info_data = { 'transaction': trans.transaction, 'status': 'initiated' } payment.save(update_fields=['info']) return self.redirect(request, trans.payment_url)
def execute_payment(self, request: HttpRequest, payment: OrderPayment): currency_type = request.session['payment_ethereum_currency_type'] payment_timestamp = request.session['payment_ethereum_time'] payment_amount = request.session['payment_ethereum_amount'] payment.info_data = { 'currency_type': currency_type, 'time': payment_timestamp, 'amount': payment_amount, } payment.save(update_fields=['info'])
def execute_payment(self, request: HttpRequest, payment: OrderPayment): currency_type = request.session['payment_ethereum_currency_type'] payment_timestamp = request.session['payment_ethereum_time'] truncated_amount_in_wei = request.session['payment_ethereum_amount'] amount_plus_payment_id = truncated_amount_in_wei + payment.id payment.info_data = { 'currency_type': currency_type, 'time': payment_timestamp, 'amount': amount_plus_payment_id, } payment.save(update_fields=['info'])
def payment_prepare(self, request: HttpRequest, payment: OrderPayment) -> Union[bool, str, None]: for p in payment.order.positions.all(): if p.item.issue_giftcard: messages.error( request, _("You cannot pay with gift cards when buying a gift card." )) return try: gc = self.event.organizer.accepted_gift_cards.get( secret=request.POST.get("giftcard")) if gc.currency != self.event.currency: messages.error( request, _("This gift card does not support this currency.")) return if gc.testmode and not payment.order.testmode: messages.error( request, _("This gift card can only be used in test mode.")) return if not gc.testmode and payment.order.testmode: messages.error( request, _("Only test gift cards can be used in test mode.")) return if gc.value <= Decimal("0.00"): messages.error( request, _("All credit on this gift card has been used.")) return payment.info_data = {'gift_card': gc.pk, 'retry': True} payment.amount = min(payment.amount, gc.value) payment.save() return True except GiftCard.DoesNotExist: if self.event.vouchers.filter( code__iexact=request.POST.get("giftcard")).exists(): messages.warning( request, _("You entered a voucher instead of a gift card. Vouchers can only be entered on the first page of the shop below " "the product selection.")) else: messages.error(request, _("This gift card is not known.")) except GiftCard.MultipleObjectsReturned: messages.error( request, _("This gift card can not be redeemed since its code is not unique. Please contact the organizer of this event." ))
def orderpayment(order, date, remind_after, reminded=None, old_format=True): op_date = date op = OrderPayment(order=order, amount=11, provider='sepadebit', state=OrderPayment.PAYMENT_STATE_CONFIRMED) info_data = { 'testdata': 'is not deleted', 'account': 'Testaccount', 'iban': 'DE02120300000000202051', 'bic': 'BYLADEM1001', 'reference': 'TESTREF-123' } if old_format: info_data['date'] = op_date.strftime("%Y-%m-%d") info_data['remind_after'] = remind_after.strftime("%Y-%m-%d-%H-%M-%S") info_data['reminded'] = reminded op.info_data = info_data op.save() else: op.info_data = info_data op.save() due_date = SepaDueDate(date=op_date, reminded=reminded, remind_after=remind_after) due_date.payment = op due_date.save() return op
def execute_payment(self, request: HttpRequest, payment: OrderPayment): self._init_api() try: source = self._create_source(request, payment) except stripe.error.StripeError as e: if e.json_body and 'err' in e.json_body: err = e.json_body['error'] logger.exception('Stripe error: %s' % str(err)) else: err = {'message': str(e)} logger.exception('Stripe error: %s' % str(e)) payment.info_data = { 'error': True, 'message': err['message'], } payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action('pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'message': err['message'] }) raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch ' 'with us if this problem persists.')) ReferencedStripeObject.objects.get_or_create( reference=source.id, defaults={'order': payment.order, 'payment': payment} ) payment.info = str(source) payment.state = OrderPayment.PAYMENT_STATE_PENDING payment.save() request.session['payment_stripe_order_secret'] = payment.order.secret return self.redirect(request, source.redirect.url)
def execute_payment(self, request: HttpRequest, payment: OrderPayment): charge = self.client.charge.create( name=payment.order.event.name, description=payment.order.event.name, local_price={ "amount": payment.amount, "currency": payment.order.event.currency, }, pricing_type="fixed_price", metadata={"paymentId": payment.id}, ) payment.info = json.dumps(charge) payment.save(update_fields=["info"]) return charge.data.hosted_url
def execute_payment(self, request: HttpRequest, payment: OrderPayment): self._init_api() try: source = self._create_source(request, payment) except stripe.error.StripeError as e: if e.json_body: err = e.json_body['error'] logger.exception('Stripe error: %s' % str(err)) else: err = {'message': str(e)} logger.exception('Stripe error: %s' % str(e)) payment.info_data = { 'error': True, 'message': err['message'], } payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action('pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'message': err['message'] }) raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch ' 'with us if this problem persists.')) ReferencedStripeObject.objects.get_or_create( reference=source.id, defaults={'order': payment.order, 'payment': payment} ) payment.info = str(source) payment.state = OrderPayment.PAYMENT_STATE_PENDING payment.save() request.session['payment_stripe_order_secret'] = payment.order.secret return self.redirect(request, source.redirect.url)
def execute_payment(self, request: HttpRequest, payment: OrderPayment): pay_data = { "NotificationURL": build_absolute_uri(self.event, 'plugins:pretix_tinkoff:webhook', kwargs={ 'payment': payment.pk }), "SuccessURL": build_absolute_uri(self.event, 'plugins:pretix_tinkoff:return', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(), 'action': 'success' }), "FailURL": build_absolute_uri(self.event, 'plugins:pretix_tinkoff:return', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(), 'action': 'fail' }), 'Amount': int(payment.amount * 100), 'OrderId': "{}-{}".format(self.event.slug.upper(), payment.order.code), 'Description': "Order {}-{}".format(self.event.slug.upper(), payment.order.code), 'DATA': { 'organizer': self.event.organizer.slug, 'event': self.event.slug, 'order': payment.order.code, 'payment': payment.local_id, 'order-full-code': payment.order.full_code }, 'PayType': "O" } try: req = self._init(pay_data) except HTTPError: logger.exception('Tinkoff error: %s' % req) if req['Success'] == False: logger.exception('Tinkoff error: %s' % req) payment.info_data = { 'error': True, 'detail': req } payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action('pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'data': payment.info_data }) raise PaymentException(_('We had trouble communicating with Tinkoff. Please try again and get in touch ' 'with us if this problem persists. Detail: {}'.format(req['Details']))) ReferencedTinkoffTransaction.objects.get_or_create(order=payment.order, payment=payment, reference=req['PaymentId']) LogTransaction(paymentid=req['PaymentId'], order=payment.order, payment=payment, method='get', meta_info=json.dumps(req)) payment.info = json.dumps(req) payment.state = OrderPayment.PAYMENT_STATE_CREATED logger.info('pay_request: {}'.format(pay_data)) logger.info('pay_response: {}'.format(payment.info)) payment.save(update_fields=['info']) return self.redirect(request, req['PaymentURL'])
def execute_payment(self, request: HttpRequest, payment: OrderPayment): txn_hash = request.session['payment_ethereum_txn_hash'] txn_hash_bytes = to_bytes(hexstr=txn_hash) currency_type = request.session['payment_ethereum_currency_type'] payment_timestamp = request.session['payment_ethereum_time'] payment_amount = request.session['payment_ethereum_amount'] if Transaction.objects.filter(txn_hash=txn_hash_bytes).exists(): raise PaymentException( f'Transaction with hash {txn_hash} already used for payment') payment.info_data = { 'txn_hash': txn_hash, 'currency_type': currency_type, 'time': payment_timestamp, 'amount': payment_amount, } payment.save(update_fields=['info']) if currency_type == 'ETH': transaction = self.transaction_provider.get_transaction(txn_hash) is_valid_payment = all(( transaction.success, transaction.to == self.settings.ETH, transaction.value >= payment_amount, transaction.timestamp >= payment_timestamp, )) elif currency_type == 'DAI': transfer = self.token_provider.get_ERC20_transfer(txn_hash) is_valid_payment = all(( transfer.success, transfer.to == self.settings.DAI, transfer.value >= payment_amount, transfer.timestamp >= payment_timestamp, )) else: # unkown currency raise ImproperlyConfigured(f"Unknown currency: {currency_type}") if is_valid_payment: with db_transaction.atomic(): try: payment.confirm() except Quota.QuotaExceededException as e: raise PaymentException(str(e)) else: Transaction.objects.create(txn_hash=txn_hash_bytes, order_payment=payment)
def execute_payment(self, request: HttpRequest, payment: OrderPayment): try: # Get the correct endpoint to consume x_endpoint = self.get_settings_key('x_endpoint') if x_endpoint == 'live': url = 'https://payments.qpaypro.com/checkout/api_v1' else: url = 'https://sandbox.qpaypro.com/payment/api_v1' # Get the message body payment_body = self._get_payment_body(request, payment) # # To save the information befor send # # TO DO: to delete this action because of security issues # payment.order.log_action('pretix.event.order.payment.started', { # 'local_id': payment.local_id, # 'provider': payment.provider, # 'data': payment_body # }) # Perform the call to the endpoint req = requests.post( url, json=payment_body, ) req.raise_for_status() # Load the response to be read data = req.json() # The result is evaluated to determine the next step if not (data['result'] == 1 and data['responseCode'] == 100): raise PaymentException(data['responseText']) # To save the result payment.info = req.json() payment.confirm() except (HTTPError, PaymentException, Quota.QuotaExceededException): logger.exception('QPayPro error: %s' % req.text) try: payment.info_data = req.json() except Exception: payment.info_data = {'error': True, 'detail': req.text} payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action( 'pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'data': payment.info_data }) raise PaymentException( _('We had trouble communicating with QPayPro. Please try again and get in touch ' 'with us if this problem persists.')) return None
def shred_payment_info(self, obj: OrderPayment): if not obj.info: return d = json.loads(obj.info) new = {} if 'source' in d: new['source'] = { 'id': d['source'].get('id'), 'type': d['source'].get('type'), 'brand': d['source'].get('brand'), 'last4': d['source'].get('last4'), 'bank_name': d['source'].get('bank_name'), 'bank': d['source'].get('bank'), 'bic': d['source'].get('bic'), 'card': { 'brand': d['source'].get('card', {}).get('brand'), 'country': d['source'].get('card', {}).get('cuntry'), 'last4': d['source'].get('card', {}).get('last4'), } } if 'amount' in d: new['amount'] = d['amount'] if 'currency' in d: new['currency'] = d['currency'] if 'status' in d: new['status'] = d['status'] if 'id' in d: new['id'] = d['id'] new['_shredded'] = True obj.info = json.dumps(new) obj.save(update_fields=['info']) for le in obj.order.all_logentries().filter( action_type="pretix.plugins.stripe.event").exclude( data="", shredded=True): d = le.parsed_data if 'data' in d: for k, v in list(d['data']['object'].items()): if v not in ('reason', 'status', 'failure_message', 'object', 'id'): d['data']['object'][k] = '█' le.data = json.dumps(d) le.shredded = True le.save(update_fields=['data', 'shredded'])
def shred_payment_info(self, obj: OrderPayment): if not obj.info: return d = json.loads(obj.info) new = {} if 'source' in d: new['source'] = { 'id': d['source'].get('id'), 'type': d['source'].get('type'), 'brand': d['source'].get('brand'), 'last4': d['source'].get('last4'), 'bank_name': d['source'].get('bank_name'), 'bank': d['source'].get('bank'), 'bic': d['source'].get('bic'), 'card': { 'brand': d['source'].get('card', {}).get('brand'), 'country': d['source'].get('card', {}).get('cuntry'), 'last4': d['source'].get('card', {}).get('last4'), } } if 'amount' in d: new['amount'] = d['amount'] if 'currency' in d: new['currency'] = d['currency'] if 'status' in d: new['status'] = d['status'] if 'id' in d: new['id'] = d['id'] new['_shredded'] = True obj.info = json.dumps(new) obj.save(update_fields=['info']) for le in obj.order.all_logentries().filter( action_type="pretix.plugins.stripe.event" ).exclude(data="", shredded=True): d = le.parsed_data if 'data' in d: for k, v in list(d['data']['object'].items()): if v not in ('reason', 'status', 'failure_message', 'object', 'id'): d['data']['object'][k] = '█' le.data = json.dumps(d) le.shredded = True le.save(update_fields=['data', 'shredded'])
def capture(payment: OrderPayment): if payment.state == OrderPayment.PAYMENT_STATE_CONFIRMED: return pprov = payment.payment_provider try: if payment.info_data.get('Status') == 'CAPTURED': return if 'Token' in payment.info_data: req = pprov._post('Payment/v1/PaymentPage/Assert', json={ "RequestHeader": { "SpecVersion": "1.10", "CustomerId": pprov.settings.customer_id, "RequestId": str(uuid.uuid4()), "RetryIndicator": 0 }, "Token": payment.info_data.get('Token') }) req.raise_for_status() data = req.json() trans = data['Transaction'] if 'PaymentMeans' in data: trans['PaymentMeans'] = data['PaymentMeans'] payment.info = json.dumps(trans) payment.save(update_fields=['info']) handle_transaction_result(payment) elif payment.info_data.get('Status') == 'AUTHORIZED': handle_transaction_result(payment) else: raise PaymentException('Unknown payment state') except requests.exceptions.HTTPError as e: payment.order.log_action('pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'data': e.response.text }) raise PaymentException(_('We had trouble communicating with Saferpay. Please try again and get in touch ' 'with us if this problem persists.'))
def execute_payment(self, request: HttpRequest, payment: OrderPayment): due_date = self._due_date() ref = '%s-%s' % (self.event.slug.upper(), payment.order.code) if self.settings.reference_prefix: ref = self.settings.reference_prefix + "-" + ref try: payment.info_data = { 'account': request.session['payment_sepa_account'], 'iban': request.session['payment_sepa_iban'], 'bic': request.session['payment_sepa_bic'], 'reference': ref, 'date': due_date.strftime("%Y-%m-%d") } payment.confirm( mail_text=self.order_pending_mail_render(payment.order)) except Quota.QuotaExceededException as e: raise PaymentException(str(e)) finally: del request.session['payment_sepa_account'] del request.session['payment_sepa_iban'] del request.session['payment_sepa_bic']
def execute_payment(self, request: HttpRequest, payment: OrderPayment): due_date, reminded = self._due_date_reminded() ref = '%s-%s' % (self.event.slug.upper(), payment.order.code) if self.settings.reference_prefix: ref = self.settings.reference_prefix + "-" + ref try: payment.info_data = { 'account': request.session['payment_sepa_account'], 'iban': request.session['payment_sepa_iban'], 'bic': request.session['payment_sepa_bic'], 'reference': ref, } # add current time to due_date for remind after to take pressure of the cron job due = SepaDueDate.objects.update_or_create( payment=payment, defaults={ 'date': due_date, 'reminded': reminded, 'remind_after': now().astimezone(self.event.timezone).replace( year=due_date.year, month=due_date.month, day=due_date.day) })[0] payment.confirm( mail_text=self.order_pending_mail_render(payment.order)) except Quota.QuotaExceededException as e: due.delete() raise PaymentException(str(e)) finally: del request.session['payment_sepa_account'] del request.session['payment_sepa_iban'] del request.session['payment_sepa_bic']
def execute_payment(self, request: HttpRequest, payment: OrderPayment): payment.info_data = { 'sender_address': request.session['payment_ethereum_fm_address'], 'currency': request.session['payment_ethereum_fm_currency'], 'time': request.session['payment_ethereum_time'], 'amount': request.session['payment_ethereum_amount'], } payment.save(update_fields=['info']) try: if request.session['payment_ethereum_fm_currency'] == 'ETH': response = requests.get( f'https://api.ethplorer.io/getAddressTransactions/{self.settings.ETH}?apiKey=freekey' # noqa: E501 ) deca = response.json() if len(deca) > 0: for decc in deca: if decc['success'] == True and decc[ 'from'] == request.session[ 'payment_ethereum_fm_address']: # noqa: E501 if decc['timestamp'] > request.session[ 'payment_ethereum_time'] and decc[ 'value'] >= request.session[ 'payment_ethereum_amount']: # noqa: E501 try: payment.confirm() except Quota.QuotaExceededException as e: raise PaymentException(str(e)) else: dec = requests.get( 'https://blockscout.com/poa/dai/api?module=account&action=txlist&address=' + self.settings.DAI) # noqa: E501 deca = dec.json() for decc in deca['result']: if decc['txreceipt_status'] == '1' and decc[ 'from'] == request.session[ 'payment_ethereum_fm_address']: # noqa: E501 # if (decc['timestamp'] > request.session['payment_ethereum_time'] and decc[ # noqa: E501 # 'value'] >= request.session['payment_ethereum_amount']): try: payment.confirm() except Quota.QuotaExceededException as e: raise PaymentException(str(e)) except NameError: pass except TypeError: pass except AttributeError: pass return None
def execute_payment(self, request: HttpRequest, payment: OrderPayment, retry=True): try: if '_links' in payment.info_data: if request: return self.redirect( request, payment.info_data.get('_links').get('checkout').get( 'href')) else: return except: pass try: req = requests.post('https://api.mollie.com/v2/payments', json=self._get_payment_body(payment), headers=self.request_headers) req.raise_for_status() except HTTPError: logger.exception('Mollie error: %s' % req.text) try: d = req.json() if d.get('status') == 401 and retry: # Token might be expired, let's retry! if refresh_mollie_token(self.event, False): return self.execute_payment(request, payment, retry=False) except: d = {'error': True, 'detail': req.text} payment.fail(info=d) raise PaymentException( _('We had trouble communicating with Mollie. Please try again and get in touch ' 'with us if this problem persists.')) data = req.json() payment.info = json.dumps(data) payment.state = OrderPayment.PAYMENT_STATE_CREATED payment.save() if request: request.session[ 'payment_mollie_order_secret'] = payment.order.secret return self.redirect( request, data.get('_links').get('checkout').get('href')) else: return
def execute_payment(self, request: HttpRequest, payment: OrderPayment): payment.refresh_from_db() try: if (request.session['fm_currency'] == 'ETH'): dec = requests.get( 'https://api.ethplorer.io/getAddressTransactions/' + self.settings.ETH + '?apiKey=freekey') deca = dec.json() if len(deca) > 0: for decc in deca: if (decc['success'] == True and decc['from'] == request.session['fm_address']): if (decc['timestamp'] > request.session['time'] and decc['value'] >= request.session['amount']): try: payment.confirm() except Quota.QuotaExceededException: raise PaymentException(str(e)) else: dec = requests.get( 'https://blockscout.com/poa/dai/api?module=account&action=txlist&address=' + self.settings.DAI) deca = dec.json() for decc in deca['result']: if (decc['txreceipt_status'] == '1' and decc['from'] == request.session['fm_address']): # if (decc['timestamp'] > request.session['time'] and decc['value'] >= request.session['amount']): try: payment.confirm() except Quota.QuotaExceededException: raise PaymentException(str(e)) except NameError: pass except TypeError: pass except AttributeError: pass return None
def execute_payment(self, request: HttpRequest, payment: OrderPayment): try: payment.confirm() except Quota.QuotaExceededException as e: raise PaymentException(str(e))
def execute_payment(self, request: HttpRequest, payment: OrderPayment): self._init_api() try: payment_method_data = json.loads(request.session['{}-{}'.format( 'payment_adyen_paymentMethodData', self.method)]) rqdata = { 'amount': { 'value': self._get_amount(payment), 'currency': self.event.currency, }, 'merchantOrderReference': '{event}-{code}'.format(event=self.event.slug.upper(), code=payment.order.code), 'reference': '{event}-{code}-P-{payment}'.format( event=self.event.slug.upper(), code=payment.order.code, payment=payment.local_id), 'shopperStatement': self.statement_descriptor(payment), 'paymentMethod': payment_method_data['paymentMethod'], 'returnUrl': build_absolute_uri( self.event, 'plugins:pretix_adyen:return', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1( payment.order.secret.lower().encode()).hexdigest(), }), 'channel': 'Web', 'origin': settings.SITE_URL, 'captureDelayHours': 0, 'shopperInteraction': 'Ecommerce', **self.api_kwargs } if self.method == "scheme": rqdata['additionalData'] = {'allow3DS2': 'true'} rqdata['browserInfo'] = payment_method_data['browserInfo'] # Since we do not have the IP-address of the customer, we cannot pass rqdata['shopperIP']. try: result = self.adyen.checkout.payments(rqdata) except AdyenError as e: logger.exception('Adyen error: %s' % str(e)) payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.info = json.dumps({ 'refusalReason': json.loads(e.raw_response or {}).get('message', '') }) payment.save() payment.order.log_action( 'pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'message': json.loads(e.raw_response or {}).get('message', '') }) raise PaymentException( _('We had trouble communicating with Adyen. Please try again and get in touch ' 'with us if this problem persists.')) if 'action' in result.message: payment.info = json.dumps(result.message) payment.state = OrderPayment.PAYMENT_STATE_CREATED payment.save() payment.order.log_action('pretix.event.order.payment.started', { 'local_id': payment.local_id, 'provider': payment.provider }) return build_absolute_uri( self.event, 'plugins:pretix_adyen:sca', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1( payment.order.secret.lower().encode()).hexdigest(), }) else: payment.info = json.dumps(result.message) payment.save() self._handle_resultcode(payment) finally: del request.session['{}-{}'.format( 'payment_adyen_paymentMethodData', self.method)]
def _handle_resultcode(self, payment: OrderPayment): payment_info = json.loads(payment.info) if payment_info['resultCode'] in [ 'AuthenticationFinished', 'ChallengeShopper', 'IdentifyShopper', 'PresentToShopper', 'Received', 'RedirectShopper', ]: # At this point, the payment has already been created - so no need to set the status or log it again # payment.state = OrderPayment.PAYMENT_STATE_CREATED pass elif payment_info['resultCode'] in ['Error', 'Refused']: payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save(update_fields=['state']) payment.order.log_action('pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider }) elif payment_info['resultCode'] == 'Cancelled': payment.state = OrderPayment.PAYMENT_STATE_CANCELED payment.save(update_fields=['state']) payment.order.log_action('pretix.event.order.payment.canceled', { 'local_id': payment.local_id, 'provider': payment.provider }) elif payment_info['resultCode'] == 'Pending': payment.state = OrderPayment.PAYMENT_STATE_PENDING payment.save(update_fields=['state']) # Nothing we can log here... elif payment_info['resultCode'] == 'Authorised': payment.confirm() return payment.state
def _handle_action(self, request: HttpRequest, payment: OrderPayment, statedata=None, payload=None, md=None, pares=None): self._init_api() payment_info = json.loads(payment.info) try: if statedata: result = self.adyen.checkout.payments_details( json.loads(statedata)) elif payload: result = self.adyen.checkout.payments_details({ 'paymentData': payment_info['paymentData'], 'details': { 'payload': payload, }, }) elif md and pares: result = self.adyen.checkout.payments_details({ 'paymentData': payment_info['paymentData'], 'details': { 'MD': md, 'PaRes': pares, }, }) else: messages.error( request, _('Sorry, there was an error in the payment process.')) return eventreverse(self.event, 'presale:event.order', kwargs={ 'order': payment.order.code, 'secret': payment.order.secret }) except AdyenError as e: logger.exception('AdyenError: %s' % str(e)) messages.error( request, _('Sorry, there was an error in the payment process.')) return eventreverse(self.event, 'presale:event.order', kwargs={ 'order': payment.order.code, 'secret': payment.order.secret }) payment.info = json.dumps(result.message) payment.save(update_fields=['info']) if 'action' in result.message: return build_absolute_uri( self.event, 'plugins:pretix_adyen:sca', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1( payment.order.secret.lower().encode()).hexdigest(), }) else: state = self._handle_resultcode(payment) return eventreverse(self.event, 'presale:event.order', kwargs={ 'order': payment.order.code, 'secret': payment.order.secret }) + ('?paid=yes' if state in [ OrderPayment.PAYMENT_STATE_CONFIRMED, OrderPayment.PAYMENT_STATE_PENDING ] else '')
def execute_payment(self, request: HttpRequest, payment: OrderPayment): self._init_api() if request.session['payment_stripe_token'].startswith('src_'): try: src = stripe.Source.retrieve(request.session['payment_stripe_token'], **self.api_kwargs) if src.type == 'card' and src.card and self._use_3ds(src.card): request.session['payment_stripe_order_secret'] = payment.order.secret source = stripe.Source.create( type='three_d_secure', amount=self._get_amount(payment), currency=self.event.currency.lower(), three_d_secure={ 'card': src.id }, statement_descriptor=ugettext('{event}-{code}').format( event=self.event.slug.upper(), code=payment.order.code )[:22], metadata={ 'order': str(payment.order.id), 'event': self.event.id, 'code': payment.order.code }, redirect={ 'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(), }) }, **self.api_kwargs ) ReferencedStripeObject.objects.get_or_create( reference=source.id, defaults={'order': payment.order, 'payment': payment} ) if source.status == "pending": payment.info = str(source) payment.state = OrderPayment.PAYMENT_STATE_PENDING payment.save() return self.redirect(request, source.redirect.url) except stripe.error.StripeError as e: if e.json_body: err = e.json_body['error'] logger.exception('Stripe error: %s' % str(err)) else: err = {'message': str(e)} logger.exception('Stripe error: %s' % str(e)) payment.info_data = { 'error': True, 'message': err['message'], } payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() payment.order.log_action('pretix.event.order.payment.failed', { 'local_id': payment.local_id, 'provider': payment.provider, 'message': err['message'] }) raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch ' 'with us if this problem persists.')) try: self._charge_source(request, request.session['payment_stripe_token'], payment) finally: del request.session['payment_stripe_token']
def execute_payment(self, request: HttpRequest, payment: OrderPayment): self._init_api() if request.session['payment_stripe_token'].startswith('src_'): try: src = stripe.Source.retrieve(request.session['payment_stripe_token'], **self.api_kwargs) if src.type == 'card' and src.card and self._use_3ds(src.card): request.session['payment_stripe_order_secret'] = payment.order.secret source = stripe.Source.create( type='three_d_secure', amount=self._get_amount(payment), currency=self.event.currency.lower(), three_d_secure={ 'card': src.id }, statement_descriptor=ugettext('{event}-{code}').format( event=self.event.slug.upper(), code=payment.order.code )[:22], metadata={ 'order': str(payment.order.id), 'event': self.event.id, 'code': payment.order.code }, redirect={ 'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={ 'order': payment.order.code, 'payment': payment.pk, 'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(), }) }, **self.api_kwargs ) ReferencedStripeObject.objects.get_or_create( reference=source.id, defaults={'order': payment.order, 'payment': payment} ) if source.status == "pending": payment.info = str(source) payment.state = OrderPayment.PAYMENT_STATE_PENDING payment.save() return self.redirect(request, source.redirect.url) except stripe.error.StripeError as e: if e.json_body: err = e.json_body['error'] logger.exception('Stripe error: %s' % str(err)) else: err = {'message': str(e)} logger.exception('Stripe error: %s' % str(e)) payment.info_data = { 'error': True, 'message': err['message'], } payment.state = OrderPayment.PAYMENT_STATE_FAILED payment.save() raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch ' 'with us if this problem persists.')) try: self._charge_source(request, request.session['payment_stripe_token'], payment) finally: del request.session['payment_stripe_token']
def execute_payment(self, request: HttpRequest, payment_obj: OrderPayment): try: # After the user has confirmed their purchase, # this method will be called to complete the payment process. mp = self.init_api() order = payment_obj.order meta_info = json.loads(order.meta_info) form_data = meta_info.get('contact_form_data', {}) address = {} company = '' name = '' if hasattr(Order, 'invoice_address'): address = { "zip_code": order.invoice_address.zipcode, "street_name": order.invoice_address.street } company = order.invoice_address.company name = str(order.invoice_address.name_parts) identification_type = form_data.get('invoicing_type_tax_id', '') if identification_type == 'PASS': identification_number = form_data.get('invoicing_tax_id_pass', '') elif identification_type == 'VAT': identification_number = form_data.get('invoicing_tax_id_vat', '') else: identification_number = form_data.get('invoicing_tax_id_dni', '') price = float(payment_obj.amount) if self.settings.get('currency') is not order.event.currency: price = price * float(self.settings.get('exchange_rate')) price = round(price, 2) order_url = build_absolute_uri(request.event, 'presale:event.order', kwargs={ 'order': order.code, 'secret': order.secret }) preference = { "items": [{ "title": __('Order {slug}-{code}').format(slug=self.event.slug, code=order.code), "quantity": 1, "unit_price": price, "currency_id": self.settings.get('currency') }], "auto_return": 'all', "back_urls": { "failure": order_url, "pending": build_absolute_uri(request.event, 'plugins:pretix_mercadopago:return'), "success": build_absolute_uri(request.event, 'plugins:pretix_mercadopago:return') }, "notification_url": build_absolute_uri(request.event, 'plugins:pretix_mercadopago:return'), "statement_descriptor": __('Order {slug}-{code}').format(slug=self.event.slug, code=order.code), "external_reference": str(payment_obj.id), # "additional_info": json.dumps(order.invoice_address)[:600], "payer": { "name": name, "surname": company, "email": form_data.get('email', ''), "identification": { "type": identification_type, "number": identification_number }, "address": address }, "payment_methods": { "installments": 1 } } # Get the payment reported by the IPN. # Glossary of attributes response in https://developers.mercadopago.com # paymentInfo = mp.get_payment(kwargs["id"]) preferenceResult = mp.create_preference(preference) payment_obj.info = json.dumps(preferenceResult, indent=4) payment_obj.save() request.session['payment_mercadopago_preferece_id'] = str( preferenceResult['response']['id']) request.session['payment_mercadopago_collector_id'] = str( preferenceResult['response']['collector_id']) request.session['payment_mercadopago_order'] = order.pk request.session['payment_mercadopago_payment'] = payment_obj.pk try: if preferenceResult: if preferenceResult["status"] not in ( 200, 201 ): # ate not in ('created', 'approved', 'pending'): messages.error( request, _('We had trouble communicating with MercadoPago' + str(preferenceResult["response"]["message"]))) logger.error('Invalid payment state: ' + str(preferenceResult["response"])) return request.session['payment_mercadopago_id'] = str( preferenceResult["response"]["id"]) if (self.test_mode_message == None): link = preferenceResult["response"]["init_point"] else: link = preferenceResult["response"][ "sandbox_init_point"] return link else: messages.error( request, _('We had trouble communicating with MercadoPago' + str(preferenceResult["response"]))) logger.error('Error on creating payment: ' + str(preferenceResult["response"])) except Exception as e: messages.error( request, _('We had trouble communicating with ' + 'MercadoPago ' + str(e) + str(preferenceResult["response"]))) logger.exception('Error on creating payment: ' + str(e)) except Exception as e: messages.error( request, _('We had trouble preparing the order for ' + 'MercadoPago ' + str(e))) logger.exception('Error on creating payment: ' + str(e))