def recurring_cancel(self, rebill_customer_id, rebill_id): """ Recurring Payment Cancelation (http://www.eway.com.au/developers/api/recurring) Input Parameters: - rebill_customer_id, - rebill_id ( Output of recurring method) Output Dict: status : 'SUCCESS' or 'FAILURE' response : Rebill/Recurring Cancelation Response from eWay Web service. """ rebillDeleteClient = RebillEwayClient( customer_id=self.customer_id, username=self.eway_username, password=self.eway_password, url=self.rebill_url, ) ''' # Delete Rebill Event, using customer create rebill detail. ''' delete_rebill_response = rebillDeleteClient.delete_rebill_event(rebill_customer_id, rebill_id) # Handler error in delete_rebill_customer response if delete_rebill_response.ErrorSeverity: transaction_was_unsuccessful.send(sender=self, type="recurringDeleteRebill", response=delete_rebill_response) return {"status": "FAILURE", "response": delete_rebill_response} transaction_was_successful.send(sender=self, type="recurring", response=delete_rebill_response) return {"status": "SUCCESS", "response": delete_rebill_response}
def authorize(self, money, credit_card, options=None): card = credit_card if isinstance(credit_card, CreditCard): if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") card = { 'number': credit_card.number, 'exp_month': credit_card.month, 'exp_year': credit_card.year, 'cvc': credit_card.verification_value } try: token = self.stripe.Token.create( card=card, amount=int(money * 100), ) transaction_was_successful.send(sender=self, type="authorize", response=token) return {'status': "SUCCESS", "response": token} except self.stripe.InvalidRequestError as error: transaction_was_unsuccessful.send(sender=self, type="authorize", response=error) return {"status": "FAILURE", "response": error}
def fps_ipn_handler(self, request): uri = request.build_absolute_uri() parsed_url = urlparse.urlparse(uri) resp = self.fps_connection.verify_signature("%s://%s%s" %(parsed_url.scheme, parsed_url.netloc, parsed_url.path), request.raw_post_data) if not resp[0].VerificationStatus == "Success": return HttpResponseForbidden() data = dict(map(lambda x: x.split("="), request.raw_post_data.split("&"))) for (key, val) in data.iteritems(): data[key] = urllib.unquote_plus(val) if AmazonFPSResponse.objects.filter(transactionId=data["transactionId"]).count(): resp = AmazonFPSResponse.objects.get(transactionId=data["transactionId"]) else: resp = AmazonFPSResponse() for (key, val) in data.iteritems(): attr_exists = hasattr(resp, key) if attr_exists and not callable(getattr(resp, key, None)): if key == "transactionDate": val = datetime.datetime(*time.localtime(float(val))[:6]) setattr(resp, key, val) resp.save() if resp.statusCode == "Success": transaction_was_successful.send(sender=self.__class__, type=data["operation"], response=resp) else: if not "Pending" in resp.statusCode: transaction_was_unsuccessful.send(sender=self.__class__, type=data["operation"], response=resp) # Return a HttpResponse to prevent django from complaining return HttpResponse(resp.statusCode)
def recurring(self, money, creditcard, options=None): if not options: options = {} params = {} params['profilestartdate'] = options.get('startdate') or datetime.datetime.now().strftime("%Y-%m-%dT00:00:00Z") params['startdate'] = options.get('startdate') or datetime.datetime.now().strftime("%m%Y") params['billingperiod'] = options.get('billingperiod') or 'Month' params['billingfrequency'] = options.get('billingfrequency') or '1' params['amt'] = money params['desc'] = 'description of the billing' params['creditcardtype'] = creditcard.card_type.card_name params['acct'] = creditcard.number params['expdate'] = '%02d%04d' % (creditcard.month, creditcard.year) params['firstname'] = creditcard.first_name params['lastname'] = creditcard.last_name wpp = PayPalWPP(options.get('request', {})) try: response = wpp.createRecurringPaymentsProfile(params, direct=True) transaction_was_successful.send(sender=self, type="purchase", response=response) except PayPalFailure as e: transaction_was_unsuccessful.send(sender=self, type="purchase", response=e) # Slight skewness because of the way django-paypal # is implemented. return {"status": "FAILURE", "response": e} return {"status": response.ack.upper(), "response": response}
def purchase(self, amount, credit_card, options=None): card = credit_card if isinstance(credit_card, CreditCard): if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") card = { 'number': credit_card.number, 'exp_month': credit_card.month, 'exp_year': credit_card.year, 'cvc': credit_card.verification_value } try: response = self.stripe.Charge.create( amount=int(amount * 100), currency=self.default_currency.lower(), card=card) except self.stripe.CardError as error: transaction_was_unsuccessful.send(sender=self, type="purchase", response=error) return {'status': 'FAILURE', 'response': error} transaction_was_successful.send(sender=self, type="purchase", response=response) return {'status': 'SUCCESS', 'response': response}
def purchase(self, money, credit_card, options=None): """One go authorize and capture transaction""" options = options or {} txn = None order_number = options.get("order_number") if options else None if credit_card: card = self.convert_cc(credit_card) txn = self.beangw.purchase(money, card, None, order_number) billing_address = options.get("billing_address") if billing_address: txn.params.update({"ordName": billing_address["name"], "ordEmailAddress": billing_address["email"], "ordPhoneNumber": billing_address["phone"], "ordAddress1": billing_address["address1"], "ordAddress2": billing_address.get("address2", ""), "ordCity": billing_address["city"], "ordProvince": billing_address["state"], "ordCountry": billing_address["country"]}) elif options.get("customer_code"): customer_code = options.get("customer_code", None) txn = self.beangw.purchase_with_payment_profile(money, customer_code, order_number) txn.validate() resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="purchase", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="purchase", response=resp["response"]) return resp
def store(self, credit_card, options=None): """Store the credit card and user profile information on the gateway for future use""" card = self.convert_cc(credit_card) billing_address = options.get("billing_address") txn = self.beangw.create_payment_profile(card, billing_address) resp = txn.commit() status = "FAILURE" response = None if resp.approved() or resp.resp["responseCode"] == ["17"]: status = "SUCCESS" else: response = resp if status == "SUCCESS": transaction_was_successful.send(sender=self, type="recurring", response=response) else: transaction_was_unsuccessful.send(sender=self, type="recurring", response=response) return {"status": status, "response": response}
def purchase(self, money, credit_card, options=None): """Using Eway payment gateway , charge the given credit card for specified money""" if not options: options = {} if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") self.add_creditcard(credit_card) self.add_address(options) customer_id = self.client.create_hosted_customer(self.hosted_customer) pymt_response = self.client.process_payment(customer_id, money, options.get("invoice", 'test'), options.get("description", 'test')) if not hasattr(pymt_response, "ewayTrxnStatus"): transaction_was_unsuccessful.send(sender=self, type="purchase", response=pymt_response) return {"status": "FAILURE", "response": pymt_response} if pymt_response.ewayTrxnStatus == "False": transaction_was_unsuccessful.send(sender=self, type="purchase", response=pymt_response) return {"status": "FAILURE", "response": pymt_response} transaction_was_successful.send(sender=self, type="purchase", response=pymt_response) return {"status": "SUCCESS", "response": pymt_response}
def authorize(self, money, credit_card, options=None): """Authorization for a future capture transaction""" # TODO: Need to add check for trnAmount # For Beanstream Canada and TD Visa & MasterCard merchant accounts this value may be $0 or $1 or more. # For all other scenarios, this value must be $0.50 or greater. options = options or {} order_number = options.get("order_number") if options else None card = self.convert_cc(credit_card) txn = self.beangw.preauth(money, card, None, order_number) billing_address = options.get("billing_address") if billing_address: txn.params.update({"ordName": billing_address["name"], "ordEmailAddress": billing_address["email"], "ordPhoneNumber": billing_address["phone"], "ordAddress1": billing_address["address1"], "ordAddress2": billing_address.get("address2", ""), "ordCity": billing_address["city"], "ordProvince": billing_address["state"], "ordCountry": billing_address["country"]}) if options and "order_number" in options: txn.order_number = options.get("order_number"); txn.validate() resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="authorize", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="authorize", response=resp["response"]) return resp
def store(self, credit_card, options=None): if isinstance(credit_card, CreditCard): if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") payment_method = PaymentMethod.create(credit_card.number, credit_card.verification_value, credit_card.month, credit_card.year) else: # Using the token which has to be retained payment_method = PaymentMethod.find(credit_card) if payment_method.errors: transaction_was_unsuccessful.send(sender=self, type="store", response=payment_method) return {'status': 'FAILURE', 'response': payment_method} response = payment_method.retain() if response.errors: transaction_was_unsuccessful.send(sender=self, type="store", response=response) return {'status': 'FAILURE', 'response': response} transaction_was_successful.send(sender=self, type="store", response=response) return {'status': 'SUCCESS', 'response': response}
def purchase(self, money, credit_card, options=None): """One go authorize and capture transaction""" self._validate(credit_card) params = self.client.factory.create('ns0:multi_sale_params') params['payment_method'] = {} params['payment_method']['card_data'] = {} params['payment_method']['card_data']['card_number'] = credit_card.number params['payment_method']['card_data']['card_code'] = credit_card.verification_value params['payment_method']['card_data']['expiration_month'] = credit_card.month params['payment_method']['card_data']['expiration_year'] = credit_card.year params['payment_method']['card_data']['name_on_card'] = '%s %s' % (credit_card.first_name, credit_card.last_name) params['capture_later'] = False customer = options['customer'] params['customer']['name'] = customer.name params['customer']['email'] = customer.email params['customer']['ip'] = customer.ip_address params['customer']['address']['street_house'] = customer.address.street_house params['customer']['address']['city'] = customer.address.city if customer.address.state: params['customer']['address']['state'] = customer.address.state params['customer']['address']['zip'] = customer.address.zip_code params['customer']['address']['country_code'] = customer.address.country_code params['amount'] = money params['currency_code'] = self.default_currency product = options['product'] params['product'] = {} params['product']['description'] = product res = self.client.service.multiSale(params) transaction = PaylaneTransaction() transaction.amount = money transaction.customer_name = customer.name transaction.customer_email = customer.email transaction.product = product status = None response = None transaction.success = hasattr(res, 'OK') transaction.save() if hasattr(res, 'OK'): status = 'SUCCESS' response = {'transaction': transaction} transaction_was_successful.send(sender=self, type='purchase', response=response) else: status = 'FAILURE' response = {'error': PaylaneError(getattr(res.ERROR, 'error_number'), getattr(res.ERROR, 'error_description'), getattr(res.ERROR, 'processor_error_number', ''), getattr(res.ERROR, 'processor_error_description', '')), 'transaction': transaction } transaction_was_unsuccessful.send(sender=self, type='purchase', response=response) return {'status': status, 'response': response}
def store(self, credit_card, options=None): options = options or {} if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") token = options.pop("access_token", self.we_pay_settings["ACCESS_TOKEN"]) try: response = self.we_pay.call('/credit_card/create', { 'client_id': self.we_pay_settings["CLIENT_ID"], 'user_name': credit_card.name, 'email': options.pop("customer")["email"], 'cc_number': credit_card.number, 'cvv': credit_card.verification_value, 'expiration_month': credit_card.month, 'expiration_year': credit_card.year, 'address': options.pop("billing_address") }, token=token) except WePayError as error: transaction_was_unsuccessful.send(sender=self, type="store", response=error) return {'status': 'FAILURE', 'response': error} transaction_was_successful.send(sender=self, type="store", response=response) return {'status': 'SUCCESS', 'response': response}
def authorize(self, money, credit_card, options=None): card = credit_card if isinstance(credit_card, CreditCard): if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") card = { 'number': credit_card.number, 'exp_month': credit_card.month, 'exp_year': credit_card.year, 'cvc': credit_card.verification_value } try: token = self.stripe.Token.create( card=card, amount=money * 100 ) transaction_was_successful.send(sender=self, type="authorize", response=token) return {'status': "SUCCESS", "response": token} except self.stripe.InvalidRequestError, error: transaction_was_unsuccessful.send(sender=self, type="authorize", response=error) return {"status": "FAILURE", "response": error}
def authorize(self, money, credit_card, options=None): options = options or {} resp = self.store(credit_card, options) if resp["status"] == "FAILURE": transaction_was_unsuccessful.send(sender=self, type="authorize", response=resp['response']) return resp token = options.pop("access_token", self.we_pay_settings["ACCESS_TOKEN"]) try: resp = self.we_pay.call('/credit_card/authorize', { 'client_id': self.we_pay_settings["CLIENT_ID"], 'client_secret': self.we_pay_settings["CLIENT_SECRET"], 'credit_card_id': resp['response']['credit_card_id'] }, token=token) except WePayError as error: transaction_was_unsuccessful.send(sender=self, type="authorize", response=error) return {'status': 'FAILURE', 'response': error} params = { "auto_capture": False } params.update(options) response = self.purchase(money, resp["credit_card_id"], params) if response["status"] == "FAILURE": transaction_was_unsuccessful.send(sender=self, type="authorize", response=response["response"]) return response transaction_was_successful.send(sender=self, type="authorize", response=response["response"]) return response
def recurring(self, credit_card, options=None): card = credit_card if isinstance(credit_card, CreditCard): if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") card = { 'number': credit_card.number, 'exp_month': credit_card.month, 'exp_year': credit_card.year, 'cvc': credit_card.verification_value } try: plan_id = options['plan_id'] self.stripe.Plan.retrieve(options['plan_id']) try: response = self.stripe.Customer.create( card=card, plan=plan_id ) transaction_was_successful.send(sender=self, type="recurring", response=response) return {"status": "SUCCESS", "response": response} except self.stripe.CardError, error: transaction_was_unsuccessful.send(sender=self, type="recurring", response=error) return {"status": "FAILURE", "response": error} except self.stripe.InvalidRequestError, error: transaction_was_unsuccessful.send(sender=self, type="recurring", response=error) return {"status": "FAILURE", "response": error}
def _success(self, type, message, response, response_code=None): transaction_was_successful.send(self, type=type, response=response, response_code=response_code) return {"status": "SUCCESS", "message": message, "response": response, "response_code": response_code, }
def unstore(self, identification, options=None): options = options or {} resp = self._chargebee_request("post", "/subscriptions/%s/cancel" % identification, data=options) if 200 <= resp.status_code < 300: transaction_was_successful.send(sender=self, type="void", response=resp.json) return {"status": "SUCCESS", "response": resp.json} transaction_was_unsuccessful.send(sender=self, type="void", response=resp.json) return {"status": "FAILURE", "response": resp.json}
def braintree_notify_handler(self, request): fpath = request.get_full_path() query_string = fpath.split("?", 1)[1] result = braintree.TransparentRedirect.confirm(query_string) if result.is_success: transaction_was_successful.send(sender=self, type="sale", response=result) return self.braintree_success_handler(request, result) transaction_was_unsuccessful.send(sender=self, type="sale", response=result) return self.braintree_failure_handler(request, result)
def _success(self, type, message, response, response_code=None, **kwargs): transaction_was_successful.send(self, type=type, response=response, response_code=response_code) retval = {"status": "SUCCESS", "message": message, "response": response, "response_code": response_code, } retval.update(kwargs) return retval
def bill_recurring(self, amount, authorization, description): """ Debit a recurring transaction payment, eg. monthly subscription. Use the result of recurring() as the paylane_recurring parameter. If this transaction is successful, use it's response as input for the next bill_recurring() call. """ processing_date = datetime.datetime.today().strftime("%Y-%m-%d") res = self.client.service.resale( id_sale=authorization.sale_authorization_id, amount=amount, currency=self.default_currency, description=description, processing_date=processing_date, resale_by_authorization=authorization) previous_transaction = authorization.transaction transaction = PaylaneTransaction() transaction.amount = previous_transaction.amount transaction.customer_name = previous_transaction.customer_name transaction.customer_email = previous_transaction.customer_email transaction.product = previous_transaction.product status = None response = None transaction.success = hasattr(res, 'OK') transaction.save() if hasattr(res, 'OK'): status = 'SUCCESS' authz = PaylaneAuthorization() authz.sale_authorization_id = authorization.sale_authorization_id authz.transaction = transaction authz.save() response = {'transaction': transaction, 'authorization': authz} transaction_was_successful.send(sender=self, type='bill_recurring', response=response) else: status = 'FAILURE' response = { 'error': PaylaneError( getattr(res.ERROR, 'error_number'), getattr(res.ERROR, 'error_description'), getattr(res.ERROR, 'processor_error_number', ''), getattr(res.ERROR, 'processor_error_description', '')), 'transaction': transaction } transaction_was_unsuccessful.send(sender=self, type='bill_recurring', response=response) return {'status': status, 'response': response}
def credit(self, money, identification, options=None): """Refund a previously 'settled' transaction""" order_number = options.get("order_number") if options else None txn = self.beangw.return_purchase(identification, money, order_number) resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="credit", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="credit", response=resp["response"]) return resp
def capture(self, money, authorization, options=None): """Capture funds from a previously authorized transaction""" order_number = options.get("order_number") if options else None txn = self.beangw.preauth_completion(authorization, money, order_number) resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="capture", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="capture", response=resp["response"]) return resp
def void(self, identification, options=None): """Null/Blank/Delete a previous transaction""" """Right now this only handles VOID_PURCHASE""" txn = self.beangw.void_purchase(identification["txnid"], identification["amount"]) resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="void", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="void", response=resp["response"]) return resp
def unauthorize(self, money, authorization, options=None): """Cancel a previously authorized transaction""" txn = self.beangw.cancel_preauth(authorization) resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="unauthorize", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="unauthorize", response=resp["response"]) return resp
def handle_response(self, response, type): response_code = response.status_code xml = self._parse_xml(response.text) result = xml_to_dict(xml) if result['Request']['Response'] == 'DECLINED': transaction_was_unsuccessful.send(self, type=type, response=response, response_code=response_code) else: transaction_was_successful.send(self, type=type, response=response, response_code=response_code) return result
def credit(self, money, identification, options=None): trans = Transaction.find(identification) if not trans.errors: new_trans = trans.reverse(money) transaction_was_successful.send(sender=self, type="credit", response=trans) return {'status': "SUCCESS", "response": new_trans} transaction_was_unsuccessful.send(sender=self, type="credit", response=trans) return {"status": "FAILURE", "response": trans}
def capture(self, money, authorization, options=None): options = options or {} resp = self._chargebee_request( "post", "/invoices/charge", data={"subscription_id": authorization, "amount": money, "description": options.get("description")}, ) if 200 <= resp.status_code < 300: transaction_was_successful.send(sender=self, type="capture", response=resp.json) return {"status": "SUCCESS", "response": resp.json} transaction_was_unsuccessful.send(sender=self, type="capture", response=resp.json) return {"status": "FAILURE", "response": resp.json}
def void(self, identification, options=None): trans = Transaction.find(identification) if not trans.errors: new_trans = trans.void() transaction_was_successful.send(sender=self, type="void", response=trans) return{'status': "SUCCESS", "response": new_trans} transaction_was_unsuccessful.send(sender=self, type="void", response=trans) return{"status": "FAILURE", "response": trans}
def credit(self, money, identification, options=None): trans = Transaction.find(identification) if not trans.errors: new_trans = trans.reverse(money) transaction_was_successful.send(sender=self, type="credit", response=trans) return{'status': "SUCCESS", "response": new_trans} transaction_was_unsuccessful.send(sender=self, type="credit", response=trans) return{"status": "FAILURE", "response": trans}
def void(self, identification, options=None): trans = Transaction.find(identification) if not trans.errors: new_trans = trans.void() transaction_was_successful.send(sender=self, type="void", response=trans) return {'status': "SUCCESS", "response": new_trans} transaction_was_unsuccessful.send(sender=self, type="void", response=trans) return {"status": "FAILURE", "response": trans}
def unstore(self, identification, options=None): try: customer = self.stripe.Customer.retrieve(identification) response = customer.delete() transaction_was_successful.send(sender=self, type="unstore", response=response) return {"status": "SUCCESS", "response": response} except self.stripe.InvalidRequestError, error: transaction_was_unsuccessful.send(sender=self, type="unstore", response=error) return {"status": "FAILURE", "response": error}
def _success(self, type, message, response, response_code=None, **kwargs): transaction_was_successful.send(self, type=type, response=response, response_code=response_code) retval = { "status": "SUCCESS", "message": message, "response": response, "response_code": response_code, } retval.update(kwargs) return retval
def credit(self, identification, money=None, options=None): try: charge = self.stripe.Charge.retrieve(identification) response = charge.refund(amount=money) transaction_was_successful.send(sender=self, type="credit", response=response) return {"status": "SUCCESS", "response": response} except self.stripe.InvalidRequestError, error: transaction_was_unsuccessful.send(sender=self, type="credit", response=error) return {"status": "FAILURE", "error": error}
def notify_handler(self, request): post_data = request.POST.copy() data = {} resp_fields = { 'instId': 'installation_id', 'compName': 'company_name', 'cartId': 'cart_id', 'desc': 'description', 'amount': 'amount', 'currency': 'currency', 'authMode': 'auth_mode', 'testMode': 'test_mode', 'transId': 'transaction_id', 'transStatus': 'transaction_status', 'transTime': 'transaction_time', 'authAmount': 'auth_amount', 'authCurrency': 'auth_currency', 'authAmountString': 'auth_amount_string', 'rawAuthMessage': 'raw_auth_message', 'rawAuthCode': 'raw_auth_code', 'name': 'name', 'address': 'address', 'postcode': 'post_code', 'country': 'country_code', 'countryString': 'country', 'tel': 'phone', 'fax': 'fax', 'email': 'email', 'futurePayId': 'future_pay_id', 'cardType': 'card_type', 'ipAddress': 'ip_address', } for (key, val) in resp_fields.iteritems(): data[val] = post_data.get(key, '') try: resp = WorldPayResponse.objects.create(**data) # TODO: Make the type more generic transaction_was_successful.send(sender=self.__class__, type="purchase", response=resp) status = "SUCCESS" except: transaction_was_unsuccessful.send(sender=self.__class__, type="purchase", response=post_data) status = "FAILURE" return HttpResponse(status)
def purchase(self, money, address, options = None): options = options or {} txns = self.get_transactions_by_address(address) received = self.get_txns_sum(txns) response = [txn.__dict__ for txn in txns] if received == money: transaction_was_successful.send(sender=self, type="purchase", response=response) return {'status': 'SUCCESS', 'response': response} transaction_was_unsuccessful.send(sender=self, type="purchase", response=response) return {'status': 'FAILURE', 'response': response}
def unstore(self, identification, options = None): options = options or {} resp = self._chargebee_request('post', "/subscriptions/%s/cancel" % identification, data = options) if 200 <= resp.status_code < 300: transaction_was_successful.send(sender=self, type="void", response=resp.json()) return {'status': 'SUCCESS', 'response': resp.json()} transaction_was_unsuccessful.send(sender=self, type="void", response=resp.json()) return {'status': 'FAILURE', 'response': resp.json()}
def capture(self, money, identification, options=None): try: charge = self.stripe.Charge.retrieve(identification, api_key=self.api_key) response = charge.capture(amount=int(money * 100)) transaction_was_successful.send(sender=self, transaction_type="capture", response=response) return {'status': "SUCCESS", "response": response} except self.stripe.InvalidRequestError as error: transaction_was_unsuccessful.send(sender=self, transaction_type="capture", response=error) return {"status": "FAILURE", "response": error}
def unauthorize(self, money, authorization, options=None): """Cancel a previously authorized transaction""" txn = Adjustment(self.beangw, Adjustment.PREAUTH_COMPLETION, authorization, money) resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="unauthorize", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="unauthorize", response=resp["response"]) return resp
def capture(self, money, authorization, options=None): try: response = self.stripe.Charge.create( amount=money * 100, card=authorization, currency=self.default_currency.lower()) transaction_was_successful.send(sender=self, type="capture", response=response) return {'status': "SUCCESS", "response": response} except self.stripe.InvalidRequestError, error: transaction_was_unsuccessful.send(sender=self, type="capture", response=error) return {"status": "FAILURE", "response": error}
def capture(self, money, authorization, options = None): options = options or {} resp = self._chargebee_request("post", "/invoices/charge", data = {"subscription_id": authorization, "amount": money, "description": options.get("description")}) if 200 <= resp.status_code < 300: transaction_was_successful.send(sender=self, type="capture", response=resp.json()) return {'status': 'SUCCESS', 'response': resp.json()} transaction_was_unsuccessful.send(sender=self, type="capture", response=resp.json()) return {'status': 'FAILURE', 'response': resp.json()}
def purchase(self, money, address, options=None): options = options or {} money = Decimal(str(money)) txns = self.get_transactions_by_address(address) received = self.get_txns_sum(txns) response = [txn.__dict__ for txn in txns] if received == money: transaction_was_successful.send(sender=self, type="purchase", response=response) return {'status': 'SUCCESS', 'response': response} transaction_was_unsuccessful.send(sender=self, type="purchase", response=response) return {'status': 'FAILURE', 'response': response}
def capture(self, money, authorization, options=None): """Capture all funds from a previously authorized transaction""" product = options['product'] res = self.client.service.captureSale( id_sale_authorization=authorization.sale_authorization_id, amount=money, description=product) previous_transaction = authorization.transaction transaction = PaylaneTransaction() transaction.amount = previous_transaction.amount transaction.customer_name = previous_transaction.customer_name transaction.customer_email = previous_transaction.customer_email transaction.product = previous_transaction.product status = None response = None transaction.success = hasattr(res, 'OK') transaction.save() if hasattr(res, 'OK'): status = 'SUCCESS' authz = PaylaneAuthorization() authz.sale_authorization_id = authorization.sale_authorization_id authz.transaction = transaction authz.save() response = {'transaction': transaction, 'authorization': authz} transaction_was_successful.send(sender=self, type='bill_recurring', response=response) else: status = 'FAILURE' response = { 'error': PaylaneError( getattr(res.ERROR, 'error_number'), getattr(res.ERROR, 'error_description'), getattr(res.ERROR, 'processor_error_number', ''), getattr(res.ERROR, 'processor_error_description', '')), 'transaction': transaction } transaction_was_unsuccessful.send(sender=self, type='bill_recurring', response=response) return {'status': status, 'response': response}
def unstore(self, identification, options=None): payment_method = PaymentMethod.find(identification) if payment_method.errors: transaction_was_unsuccessful.send(sender=self, type="unstore", response=payment_method) return {"status": "FAILURE", "response": payment_method} payment_method = payment_method.redact() if payment_method.errors: transaction_was_unsuccessful.send(sender=self, type="unstore", response=payment_method) return {"status": "FAILURE", "response": payment_method} transaction_was_successful.send(sender=self, type="unstore", response=payment_method) return {"status": "SUCCESS", "response": payment_method}
def capture(self, money, authorization, options=None): options = options or {} params = { 'checkout_id': authorization, } token = options.pop("access_token", self.we_pay_settings["ACCESS_TOKEN"]) try: response = self.we_pay.call('/checkout/capture', params, token=token) except WePayError as error: transaction_was_unsuccessful.send(sender=self, type="capture", response=error) return {'status': 'FAILURE', 'response': error} transaction_was_successful.send(sender=self, type="capture", response=response) return {'status': 'SUCCESS', 'response': response}
def purchase(self, money, credit_card, options=None): """One go authorize and capture transaction""" options = options or {} txn = None order_number = options.get("order_number") if options else None if credit_card: card = self.convert_cc(credit_card) txn = self.beangw.purchase(money, card, None, order_number) billing_address = options.get("billing_address") if billing_address: txn.params.update({ "ordName": billing_address["name"], "ordEmailAddress": billing_address["email"], "ordPhoneNumber": billing_address["phone"], "ordAddress1": billing_address["address1"], "ordAddress2": billing_address.get("address2", ""), "ordCity": billing_address["city"], "ordProvince": billing_address["state"], "ordCountry": billing_address["country"] }) elif options.get("customer_code"): customer_code = options.get("customer_code", None) txn = self.beangw.purchase_with_payment_profile( money, customer_code, order_number) txn.validate() resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="purchase", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="purchase", response=resp["response"]) return resp
def void(self, identification, options=None): options = options or {} params = { 'checkout_id': identification, 'cancel_reason': options.pop("description", "") } token = options.pop("access_token", self.we_pay_settings["ACCESS_TOKEN"]) try: response = self.we_pay.call('/checkout/cancel', params, token=token) except WePayError as error: transaction_was_unsuccessful.send(sender=self, type="void", response=error) return {'status': 'FAILURE', 'response': error} transaction_was_successful.send(sender=self, type="void", response=response) return {'status': 'SUCCESS', 'response': response}
def purchase(self, money, credit_card, options=None): """ Using Eway payment gateway , charge the given credit card for specified money """ if not options: options = {} if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") client = RebillEwayClient(customer_id=self.customer_id, username=self.eway_username, password=self.eway_password, url=self.service_url, ) hosted_customer = client.client.factory.create("CreditCard") self.add_creditcard(hosted_customer, credit_card) self.add_address(hosted_customer, options) customer_id = client.create_hosted_customer(hosted_customer) pymt_response = client.process_payment( customer_id, money, options.get("invoice", 'test'), options.get("description", 'test') ) if not hasattr(pymt_response, "ewayTrxnStatus"): transaction_was_unsuccessful.send(sender=self, type="purchase", response=pymt_response) return {"status": "FAILURE", "response": pymt_response} if pymt_response.ewayTrxnStatus == "False": transaction_was_unsuccessful.send(sender=self, type="purchase", response=pymt_response) return {"status": "FAILURE", "response": pymt_response} transaction_was_successful.send(sender=self, type="purchase", response=pymt_response) return {"status": "SUCCESS", "response": pymt_response}
def authorize(self, money, credit_card, options=None): payment_method_token = credit_card if isinstance(credit_card, CreditCard): if not self.validate_card(credit_card): raise InvalidCard("Invalid Card") pm = PaymentMethod.create(credit_card.number, credit_card.verification_value, credit_card.month, credit_card.year) payment_method_token = pm.payment_method_token response = Processor.authorize(payment_method_token, money) if response.errors: transaction_was_unsuccessful.send(sender=self, type="authorize", response=response) return {'status': 'FAILURE', 'response': response} transaction_was_successful.send(sender=self, type="authorize", response=response) return {'status': 'SUCCESS', 'response': response}
def purchase(self, money, credit_card, options = None): """Create a plan that bills every decade or so and charge the plan immediately""" options = options or {} resp = self.store(credit_card, options = options) subscription_id = resp["response"]["subscription"]["id"] resp = self._chargebee_request("post", "/invoices/charge", data = {"subscription_id": subscription_id, "amount": money, "description": options.get("description")}) if 200 <= resp.status_code < 300: transaction_was_successful.send(sender=self, type="purchase", response=resp.json()) return {'status': 'SUCCESS', 'response': resp.json()} transaction_was_unsuccessful.send(sender=self, type="purchase", response=resp.json()) return {'status': 'FAILURE', 'response': resp.json()}
def store(self, credit_card, options = None): options = options or {} if isinstance(credit_card, CreditCard): options.update({"card[first_name]": credit_card.first_name, "card[last_name]": credit_card.last_name, "card[number]": credit_card.number, "card[expiry_year]": credit_card.year, "card[expiry_month]": credit_card.month, "card[cvv]": credit_card.verification_value}) resp = self._chargebee_request('post', "/subscriptions", data = options) if 200 <= resp.status_code < 300: transaction_was_successful.send(sender=self, type="store", response=resp.json()) return {'status': 'SUCCESS', 'response': resp.json()} transaction_was_unsuccessful.send(sender=self, type="store", response=resp.json()) return {'status': 'FAILURE', 'response': resp.json()}
def authorize(self, money, credit_card, options=None): """Authorization for a future capture transaction""" # TODO: Need to add check for trnAmount # For Beanstream Canada and TD Visa & MasterCard merchant accounts this value may be $0 or $1 or more. # For all other scenarios, this value must be $0.50 or greater. options = options or {} order_number = options.get("order_number") if options else None card = self.convert_cc(credit_card) txn = self.beangw.preauth(money, card, None, order_number) billing_address = options.get("billing_address") if billing_address: txn.params.update({ "ordName": billing_address["name"], "ordEmailAddress": billing_address["email"], "ordPhoneNumber": billing_address["phone"], "ordAddress1": billing_address["address1"], "ordAddress2": billing_address.get("address2", ""), "ordCity": billing_address["city"], "ordProvince": billing_address["state"], "ordCountry": billing_address["country"] }) if options and "order_number" in options: txn.order_number = options.get("order_number") txn.validate() resp = self._parse_resp(txn.commit()) if resp["status"] == "SUCCESS": transaction_was_successful.send(sender=self, type="authorize", response=resp["response"]) else: transaction_was_unsuccessful.send(sender=self, type="authorize", response=resp["response"]) return resp
def recurring(self, money, credit_card, options=None): options = options or {} params = { 'account_id': self.we_pay_settings.get("ACCOUNT_ID", ""), "short_description": options.pop("description", ""), "amount": money, } params.update(options) token = options.pop("access_token", self.we_pay_settings["ACCESS_TOKEN"]) try: response = self.we_pay.call("/preapproval/create", params, token=token) except WePayError as error: transaction_was_unsuccessful.send(sender=self, type="recurring", response=error) return {'status': 'FAILURE', 'response': error} transaction_was_successful.send(sender=self, type="recurring", response=response) return {'status': 'SUCCESS', 'response': response}