def test_order_payment_POST(base_items, user_client, user_user):
gateway = braintree.BraintreeGateway(settings.BRAINTREE_CONF)
user = user_user
client = user_client
order = OrderFactory(user=user)
url3 = reverse("payments:order_payment", kwargs={"order_id": order.id})
# FAILED
response = client.post(url3)
assert response.status_code == 302
order = Order.objects.get(id=order.id)
session = client.session
assert order.status == "unpaid"
with pytest.raises(KeyError):
assert session[settings.CART_SESSION_ID]
## CELERY TASK
# result = order_confirmation.delay(order.id, order.status, '/')
# print(result)
# ACCEPTED
result = gateway.transaction.sale(
{
"amount": "10.00",
"payment_method_nonce": "fake-valid-nonce",
"options": {"submit_for_settlement": True},
}
)
assert result.is_success
def payment_process(request: WSGIRequest, id: int) -> HttpResponse:
gateway = braintree.BraintreeGateway(settings.BRAINTREE_CONF)
order_info = OrderInformation.objects.get(id=id)
order_items = OrderItem.objects.filter(order_information=order_info).all()
total_cost = sum(order_item.get_total_cost for order_item in order_items)
if request.method == "POST":
nonce = request.POST.get('payment_method_nonce', None)
result = gateway.transaction.sale({
'amount': f"{total_cost:.2f}",
'payment_method_nonce': nonce,
'options': {
'submit_for_settlement': True
}
})
if result.is_success:
order_info.paid = True
order_info.braintree_id = result.transaction.id
order_info.save()
return redirect('payment_done')
return redirect('payment_canceled')
else:
client_token = gateway.client_token.generate()
return render(request,
'payment/process.html', {
'order': order_info,
'item': order_items,
'client_token': client_token
},
status=HTTPStatus.OK)
def init_braintree_gateway(app):
"""Configure the Braintree API gateway.
:param app: The current app.
:return: Braintree gateway.
"""
with app.app_context():
# The default environment is set to the Sandbox.
merchant_id = app.config['MERCHANT_ID']
public_key = app.config['MERCHANT_PUBLIC_KEY']
private_key = app.config['MERCHANT_PRIVATE_KEY']
braintree_environment = app.config['BRAINTREE_ENVIRONMENT']
if braintree_environment == 'production':
braintree_environment = braintree.Environment.Production
else:
braintree_environment = braintree.Environment.Sandbox
gateway = braintree.BraintreeGateway(
braintree.Configuration(braintree_environment,
merchant_id=merchant_id,
public_key=public_key,
private_key=private_key))
return gateway
def payments(request):
gateway = braintree.BraintreeGateway(
braintree.Configuration(
environment=braintree.Environment.Sandbox,
merchant_id='t2w5dbzprv32crd7',
public_key='q2np62tjvdmmn6fk',
private_key='814c67e277a7bc12bdfa448c6ed32e6f' )
)
client_token = gateway.client_token.generate()
if request.method=='POST':
#return redirect("/takethis")
nonce=request.POST.get('payment_method_nonce',None)
payment_amt=request.POST.get('payment_amt',"ERROR")
try:
if(float(payment_amt)<0 or float(payment_amt)>100000):
return JsonResponse({"LOL":"NO"})
except:
return JsonResponse({"LOL":"NO"})
print(payment_amt)
result = gateway.transaction.sale({
"amount": payment_amt,
"payment_method_nonce": nonce,
"options": {
"submit_for_settlement": True
}
})
if result.is_success:
return JsonResponse({"LOL":"YUH"})
else:
return JsonResponse({"LOL":"NO"})
context={"token":client_token}
template=loader.get_template('payments/index.html')
return HttpResponse(template.render(context,request))
def __init__(self, *args, **kwargs):
if settings.BRAINTREE_PRODUCTION:
braintree_env = braintree.Environment.Production
else:
braintree_env = braintree.Environment.Sandbox
# Configure Braintree
braintree_config = braintree.Configuration(
braintree_env,
merchant_id=settings.BRAINTREE_MERCHANT_ID,
public_key=settings.BRAINTREE_PUBLIC_KEY,
private_key=settings.BRAINTREE_PRIVATE_KEY,
)
self.gateway = braintree.BraintreeGateway(braintree_config)
self.braintree_client_token = self.gateway.client_token.generate({})
self.co_params = {}
amount = kwargs.pop('amount', None)
self.invnum = kwargs.pop('invnum', None)
currency = kwargs.pop('currency', None)
retval = super().__init__(*args, **kwargs)
self.initial['installment'] = InstallmentTypes.FULL # default
self.initial['amount'] = amount
return retval
def get_gateway():
gateway = braintree.BraintreeGateway(
braintree.Configuration(environment=braintree.Environment.Sandbox,
merchant_id=settings.BRAINTREE_MERCHANT_ID,
public_key=settings.BRAINTREE_PUBLIC_KEY,
private_key=settings.BRAINTREE_PRIVATE_KEY))
return gateway
def post(self, request, *args, **kwargs):
gateway = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Sandbox,
merchant_id=os.environ.get("BRAINTREE_MERCHANT_ID"),
public_key=os.environ.get("BRAINTREE_PUBLIC_KEY"),
private_key=os.environ.get("BRAINTREE_PRIVATE_KEY")))
# Parse Braintree webhook
body = json.loads(request.body)
webhook_notification = gateway.webhook_notification.parse(
body["bt_signature"], body["bt_payload"])
braintree_subscription = webhook_notification.subscription
# Make sure we can find the subscription
subscription = get_object_or_404(
Subscription, braintree_subscription_id=braintree_subscription.id)
if webhook_notification.kind == "subscription_charged_successfully":
# Grace period so subscribers maintain access
grace_period = timedelta(days=5)
# Use Braintree paid through date (with grace period), if available
if braintree_subscription.get("paid_through_date"):
subscription.end_date = braintree_subscription.paid_through_date + grace_period
# Otherwise extend by one year with grace period
else:
one_year_with_grace = timedelta(days=365) + grace_period
subscription.end_date = subscription.end_date + one_year_with_grace
subscription.save()
return HttpResponse()
def get_braintree_gateway():
return braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Sandbox,
merchant_id=os.environ.get("BRAINTREE_MERCHANT_ID"),
public_key=os.environ.get("BRAINTREE_PUBLIC_KEY"),
private_key=os.environ.get("BRAINTREE_PRIVATE_KEY"),
))
def __init__(self):
mode = braintree.Environment.Production if braintree_config.CONFIG_MODE == "live" else braintree.Environment.Sandbox
self.configuration = braintree.Configuration(
mode,
merchant_id=braintree_config.CONFIG_MERCHANT_ID,
public_key=braintree_config.CONFIG_PUBLIC_KEY,
private_key=braintree_config.CONFIG_PRIVATE_KEY)
self.gateway = braintree.BraintreeGateway(self.configuration)
def configure_braintree(self):
self.gateway = braintree.BraintreeGateway(
braintree.Configuration(
environment=braintree.Environment.Sandbox
if self.use_sandbox else braintree.Environment.Production,
merchant_id=self.merchant_id,
public_key=self.public_key,
private_key=self.get_password(fieldname='private_key',
raise_exception=False)))
def payment_process(request):
order_id = request.session['order_id']
order = get_object_or_404(Order, id=order_id)
if request.method == 'POST':
nonce = request.POST.get('payment_method_nonce', None)
result = braintree.Transaction.sale({
'amount':
'{:.2f}'.format(order.get_total_cost()),
'payment_method_nonce':
nonce,
"options": {
"submit_for_settlement": True
}
})
if result.is_success:
order.paid = True
order.braintree_id = result.transaction.id
order.save()
#record products to be bought together
r = Recommender()
products = [item.product for item in order.items.all()]
r.products_bought(products)
#create mail of invoice
subject = "My shop - invoice no. {}".format(order.id)
message = 'Please, find attateched the invoice for your recent purchases.'
email = EmailMessage(subject, message, '*****@*****.**',
[order.email])
html = render_to_string('admin/orders/order/pdf.html',
{'order': order})
stylesheets = [
weasyprint.CSS(settings.STATIC_ROOT + 'css/pdf.css')
]
out = weasyprint.HTML(string=html).write_pdf(
stylesheets=stylesheets)
email.attach('order_{}'.format(order.id), out, 'application/pdf')
email.send()
return redirect('payment:done')
else:
return redirect('payment:canceled')
else:
#client_token=braintree.ClientToken.generate()
gateway = braintree.BraintreeGateway(
braintree.Configuration.instantiate())
client_token = gateway.client_token.generate()
return render(request, 'payment/process.html', {
'order': order,
'client_token': client_token
})
def __init__(self,config): self.gateway = braintree.BraintreeGateway( braintree.Configuration( environment = config['environment'], merchant_id = config['merchant_id'], public_key = config['public_key'], private_key = config['private_key'], ) )
def __init__(self):
self.gateway = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Production,
merchant_id=os.getenv('BRAINTREE_MERCHANT_ID'),
public_key=os.getenv('BRAINTREE_PUBLIC_KEY'),
private_key=os.getenv('BRAINTREE_PRIVATE_KEY')))
self.kount_url = os.getenv('KOUNT_URL')
self.kount_api_key = os.getenv('KOUNT_API_KEY')
def __init__(self, access_token=None): # add user param ?
# django user who is performing a transaction
# self.user = user
# override the access_token if its specified
if access_token is not None:
self.access_token = access_token
# setup the gateway which will help us do braintree/vzero things
self.gateway = braintree.BraintreeGateway(access_token=self.access_token)
def gateway(app):
instance = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Sandbox,
merchant_id=app.config.get('BT_MERCHANT_ID'),
public_key=app.config.get('BT_PUBLIC_KEY'),
private_key=app.config.get('BT_PRIVATE_KEY')
)
)
return instance
def try_connect(self, logger: AirbyteLogger, config: json):
"""Test provided credentials, raises self.api_error if something goes wrong"""
client = braintree.BraintreeGateway(
braintree.Configuration(
environment=getattr(braintree.Environment, config["environment"]),
merchant_id=config["merchant_id"],
public_key=config["public_key"],
private_key=config["private_key"],
)
)
client.transaction.search(braintree.TransactionSearch.created_at.between(datetime.now() + relativedelta(days=-1), datetime.now()))
def test_order_payment_GET(base_items, user_client, user_user):
gateway = braintree.BraintreeGateway(settings.BRAINTREE_CONF)
user = user_user
client = user_client
order = OrderFactory(user=user)
url3 = reverse("payments:order_payment", kwargs={"order_id": order.id})
response = client.get(url3)
assert response.status_code == 200
assert response.context["client_token"]
response = Client().get(url3)
assert response.status_code == 403
def get_braintree_gateway(sandbox_mode, merchant_id, public_key, private_key):
if not all([merchant_id, private_key, public_key]):
raise ImproperlyConfigured('Incorrectly configured Braintree gateway.')
environment = braintree_sdk.Environment.Sandbox
if not sandbox_mode:
environment = braintree_sdk.Environment.Production
config = braintree_sdk.Configuration(environment=environment,
merchant_id=merchant_id,
public_key=public_key,
private_key=private_key)
gateway = braintree_sdk.BraintreeGateway(config=config)
return gateway
def payments(request):
paypalrestsdk.configure({
"mode": "sandbox", # sandbox or live
"client_id": "",
"client_secret": ""
})
access_token = ''
gateway = braintree.BraintreeGateway(access_token=access_token)
client_token = gateway.client_token.generate()
if request.method == 'POST':
payment = paypalrestsdk.Payment({
"intent":
"sale",
"payer": {
"payment_method": "paypal"
},
"redirect_urls": {
"return_url": "http://localhost:8000/payment/execute",
"cancel_url": "http://localhost:8000/"
},
"transactions": [{
"item_list": {
"items": [{
"name": "item",
"sku": "item",
"price": "5.00",
"currency": "USD",
"quantity": 1
}]
},
"amount": {
"total": "5.00",
"currency": "USD"
},
"description":
"This is the payment transaction description."
}]
})
if payment.create():
print("Payment created successfully")
else:
print(payment.error)
context = {
'client_token': client_token,
}
return render(request, 'app/paypal.html')
def __init__(self):
# instance variable unique to each instance
try:
self.payment_gateway = PaymentGateway.objects.get(
pk=PAYMENT_GATEWAYS['BRAINTREE'])
except ObjectDoesNotExist as error:
logger.error(error)
return
self.merchant_id = self.payment_gateway.merchant_id
self.public_key = self.payment_gateway.public_key
self.private_key = self.payment_gateway.private_key
self.gateway = braintree.BraintreeGateway(
braintree.Configuration(environment=braintree.Environment.Sandbox,
merchant_id=self.merchant_id,
public_key=self.public_key,
private_key=self.private_key))
class PaymentProcessors:
PAYMENT_GATEWAYS = {
'braintree': braintree.BraintreeGateway(BRAINTREE_CONFIG)
}
def __init__(self, name: str):
self._get(name)
def _get(self, name: str):
self.processor = self.PAYMENT_GATEWAYS.get(name)
if self.processor is None:
raise InvalidPaymentProcessorPaymentInformation
def create_customer(self, details: dict):
result = self.processor.customer.create(details)
if result.is_success is False:
raise InvalidPaymentProcessorCustomerInformation
return {'customer_id': result.customer.id}
def create_payment_method(self, details: dict):
result = self.processor.credit_card.create(details)
if result.is_success is False:
raise InvalidPaymentProcessorPaymentInformation
return {'payment_token': result.credit_card.token}
def create_payment_method_nonce(self, details):
result = self.processor.payment_method_nonce.create(
details['payment_token'])
if result.is_success is False:
raise InvalidPaymentProcessorPaymentInformation
return {'payment_method_nonce': result.payment_method_nonce.nonce}
def create_sale(self, details: dict):
result = self.processor.transaction.sale(details)
if result.is_success is False:
raise InvalidPaymentMethod
return result.is_success
def __init__(self):
test_mode = getattr(settings, "MERCHANT_TEST_MODE", True)
if test_mode:
env = braintree.Environment.Sandbox
else:
env = braintree.Environment.Production
merchant_settings = getattr(settings, "MERCHANT_SETTINGS")
if not merchant_settings or not merchant_settings.get("braintree_payments"):
raise GatewayNotConfigured("The '%s' gateway is not correctly "
"configured." % self.display_name)
self.braintree_settings = merchant_settings['braintree_payments']
self.configuration = braintree.Configuration(
environment=env,
merchant_id=self.braintree_settings['MERCHANT_ACCOUNT_ID'],
public_key=self.braintree_settings['PUBLIC_KEY'],
private_key=self.braintree_settings['PRIVATE_KEY']
)
self.braintree = braintree.BraintreeGateway(self.configuration)
def __init__(self,
merchant_id=None,
public_key=None,
private_key=None,
timeout=None,
production=True):
merchant_id = check_env('BRAINTREE_MERCHANT_ID', merchant_id)
public_key = check_env('BRAINTREE_PUBLIC_KEY', public_key)
private_key = check_env('BRAINTREE_PRIVATE_KEY', private_key)
timeout = check_env('BRAINTREE_TIMEOUT', timeout, optional=True) or 200
self.gateway = braintree.BraintreeGateway(
braintree.Configuration(
environment=(braintree.Environment.Production
if production else braintree.Environment.Sandbox),
merchant_id=merchant_id,
public_key=public_key,
private_key=private_key,
timeout=timeout))
def get(self, request):
user = request.user
gateway = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Sandbox,
merchant_id=settings.BRAINTREE_MERCHANT_ID,
public_key=settings.BRAINTREE_PUBLIC_KEY,
private_key=settings.BRAINTREE_PRIVATE_KEY))
# result = gateway.customer.create({
# "first_name": user.first_name,
# "email": user.email
# }
# )
# if result.is_success:
# user.customer_id = result.customer.id
# user.save()
client_token = gateway.client_token.generate(
{"customer_id": user.customer_id})
return Response({"client_token": client_token})
def __init__(
self,
environment='sandbox',
merchant_id=__MERCHANT_ID,
public_key=__PUBLIC_KEY,
private_key=__PRIVATE_KEY,
):
environment = environment if valid_str(environment) else 'sandbox'
merchant_id = merchant_id if valid_str(
merchant_id) else self.__MERCHANT_ID
public_key = public_key if valid_str(public_key) else self.__PUBLIC_KEY
private_key = private_key if valid_str(
private_key) else self.__PRIVATE_KEY
self.gateway = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.parse_environment(environment),
merchant_id=merchant_id,
public_key=public_key,
private_key=private_key))
def __init__(self, country, environment='prod'):
self.country = country
self.logger = logging.getLogger('billing')
self.merchant_id = get_settings('BRAINTREE_MERCHANT_ID',
country=self.country)
self.public_key = get_settings('BRAINTREE_PUBLIC_KEY',
country=self.country)
self.private_key = get_settings('BRAINTREE_PRIVATE_KEY',
country=self.country)
if environment == 'prod':
env = braintree.Environment.Production
else:
env = braintree.Environment.Sandbox
self.gateway = braintree.BraintreeGateway(
braintree.Configuration(
environment=env,
merchant_id=self.merchant_id,
public_key=self.public_key,
private_key=self.private_key,
))
def check(self, logger: AirbyteLogger, config_container: ConfigContainer) -> AirbyteConnectionStatus:
try:
json_config = config_container.rendered_config
client = braintree.BraintreeGateway(
braintree.Configuration(
environment=getattr(braintree.Environment, json_config["environment"]),
merchant_id=json_config["merchant_id"],
public_key=json_config["public_key"],
private_key=json_config["private_key"],
)
)
client.transaction.search(
braintree.TransactionSearch.created_at.between(datetime.now() + relativedelta(days=-1), datetime.now())
)
return AirbyteConnectionStatus(status=Status.SUCCEEDED)
except AuthenticationError:
logger.error("Exception while connecting to the Braintree API")
return AirbyteConnectionStatus(
status=Status.FAILED,
message="Unable to connect to the Braintree API with the provided credentials. Please make sure the input credentials and environment are correct.",
)
def post(self, request):
user = request.user
gateway = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Sandbox,
merchant_id=settings.BRAINTREE_MERCHANT_ID,
public_key=settings.BRAINTREE_PUBLIC_KEY,
private_key=settings.BRAINTREE_PRIVATE_KEY))
result = gateway.transaction.sale({
"amount":
request.data.get('amount'),
"payment_method_nonce":
request.data.get('payment_method_nonce'),
"options": {
"submit_for_settlement": True
}
})
if result.is_success:
return Response({"response": result.transaction.id})
else:
return Response({"response": result.message})
def __init__(
self,
merchant_id: str,
public_key: str,
private_key: str,
use_sandbox: bool = False,
):
"""
Initialise a basic Braintree connection.
See: https://developers.braintreepayments.com/start/hello-server/python
"""
environment = (braintree.Environment.Sandbox
if use_sandbox else braintree.Environment.Production)
self._gateway = braintree.BraintreeGateway(
braintree.Configuration(
environment,
merchant_id=merchant_id,
public_key=public_key,
private_key=private_key,
))
def create_braintree_customer(self, request):
user = request.user
f = open("post_requst_data.txt", "a")
f.write("{}\n".format(request.data))
if 'cof' in request.data:
if 'cof_payment' not in request.data:
attachment = get_random_string(length=10)
return Response(data={'attachment': attachment})
if 'cof_payment' in request.data:
self.order_placed_handled()
if 'payment_method_nonce' in request.data:
self.order_placed_handled()
if 'cof' not in request.data:
config = braintree.BraintreeGateway(
braintree.Configuration(
braintree.Environment.Production,
merchant_id=settings.BRAINTREE_MERCHANT_ID,
public_key=settings.BRAINTREE_PUBLIC_KEY,
private_key=settings.BRAINTREE_PRIVATE_KEY))
if user.braintree_customer_id is None:
create_customer = config.customer.create({
"email":
request.user.email,
"first_name":
request.user.first_name,
"last_name":
request.user.last_name
})
user.braintree_customer_id = create_customer.customer.id
user.save()
client_token = config.client_token.generate(
{"customer_id": user.braintree_customer_id})
return Response(data={'client_token': client_token})
return Response(data={'result': True})
