def get_dwolla_client():
client = dwolla.Client(
id=settings.DWOLLA_API_KEY,
secret=settings.DWOLLA_SECRET_KEY,
environment='sandbox' if settings.USE_FAKE else 'production')
return client.Auth.client()
def create_verified_customer(user):
"""
Creates Dwolla verified customer
and plugin to User model
"""
client = dwollav2.Client(id=settings.DWOLLA_ID_SANDBOX,
secret=settings.DWOLLA_SECRET_SANDBOX,
environment=settings.PLAID_ENV)
app_token = client.Auth.client()
request_body = {
'firstName': user.first_name,
'lastName': user.last_name,
'email': user.email,
'type': user.type,
'address1': user.address1,
'city': user.city,
'state': user.state,
'postalCode': user.postal_code,
'dateOfBirth': str(user.date_of_birth),
'ssn': user.ssn
}
missed_fields = has_missed_fields(request_body)
if missed_fields:
return missed_fields
customer = app_token.post('customers', request_body)
user.dwolla_verified_url = customer.headers['location']
user.save()
return missed_fields
def test_auth(self):
client = dwollav2.Client(id=self.id, secret=self.secret)
redirect_uri = "redirect-uri"
self.assertEqual(
client.auth(redirect_uri=redirect_uri).url,
'https://accounts.dwolla.com/auth?client_id=client-id&redirect_uri=%s&response_type=code'
% redirect_uri)
def clean_data(uid, phone):
auth.delete_user(uid) #Clear Firebase
client = boto3.resource(
'dynamodb',
region_name='us-east-1',
aws_access_key_id=keys['aws_access_key_id'],
aws_secret_access_key=keys['aws_secret_access_key'])
table = client.Table('DrackerUser')
#Clear Entry in Dwolla
item = table.get_item(Key={'phone': phone})
url = item['Item']['customer_url']
request_body = {'status': 'deactivated'}
dwollaclient = dwollav2.Client(key=keys['dwolla_key'],
secret=keys['dwolla_secret'],
environment=keys['dwolla_env'])
app_token = dwollaclient.Auth.client()
app_token.post(url, request_body)
#Clear Entry in DrackerUser
table.delete_item(Key={'phone': phone})
#Remove table
while True:
try:
client.Table(uid).delete()
break
except client.meta.client.exceptions.ResourceInUseException:
pass
def __init__(self):
self.client = dwollav2.Client(
key=DWOLLA_SETTINGS.get('app_key'),
secret=DWOLLA_SETTINGS.get('app_secret'),
environment=DWOLLA_SETTINGS.get('environment'))
self.url = DWOLLA_SETTINGS.get('url')
self.token = self.client.Auth.client()
self.webhook_secret = settings.SECRET_KEY
def test_sets_on_grant(self):
def on_grant(x):
return x
client = dwollav2.Client(id=self.id,
secret=self.secret,
on_grant=on_grant)
self.assertEqual(on_grant, client.on_grant)
def test_refresh_token_error(self):
client = dwollav2.Client(id=self.id, secret=self.secret)
responses.add(responses.POST,
client.token_url,
body='{"error": "bad"}',
status=200,
content_type='application/json')
with self.assertRaises(dwollav2.Error):
client.refresh_token(refresh_token='refresh-token')
def test_refresh_token_success(self):
client = dwollav2.Client(id=self.id, secret=self.secret)
responses.add(responses.POST,
client.token_url,
body='{"access_token": "abc"}',
status=200,
content_type='application/json')
token = client.refresh_token(refresh_token='refresh-token')
self.assertEqual('abc', token.access_token)
def test_instance_callback_success_with_none_on_grant(self):
client = dwollav2.Client(id='id', secret='secret')
auth = client.Auth(redirect_uri=self.redirect_uri,
scope=self.scope,
state=self.state)
responses.add(responses.POST,
client.token_url,
body='{"access_token": "abc"}',
status=200,
content_type='application/json')
params = {'state': self.state, 'code': 'def'}
token = auth.callback(params)
self.assertEqual('abc', token.access_token)
def lambda_handler(event, context):
try:
phone = event['phone']
account_id = event['account_id']
token = event['token']
account_name = event["name"]
institution_name = event["institution_name"]
item = table.get_item(Key={'phone': phone})
item = item['Item']
customer_url = item['customer_url']
plaid_client = Client(client_id=os.environ.get('plaid_client'),
secret=os.environ.get('plaid_secret'),
public_key=os.environ.get('plaid_public'),
environment=os.environ.get('plaid_env'))
exchange_token_response = plaid_client.Item.public_token.exchange(
token)
access_token = exchange_token_response['access_token']
dwolla_response = plaid_client.Processor.dwollaBankAccountTokenCreate(
access_token, account_id)
bank_account_token = dwolla_response['processor_token']
request_body = {'plaidToken': bank_account_token, 'name': account_name}
dwolla_client = dwollav2.Client(
key=os.environ.get('dwolla_key'),
secret=os.environ.get('dwolla_secret'),
environment=os.environ.get('dwolla_env'))
app_token = dwolla_client.Auth.client()
funding_source = app_token.post('%s/funding-sources' % customer_url,
request_body)
source_url = funding_source.headers['location']
new_account = {
"url": source_url,
"name": account_name,
"institution": institution_name
}
if item.has_key('funding_source'):
data = json.loads(item['funding_source'])
data["list"].append(new_account)
item['funding_source'] = json.dumps(data)
else:
data = {"default": new_account, "list": [new_account]}
item['funding_source'] = json.dumps(data)
table.put_item(Item=item)
return {"message": "SUCCESS", "url": source_url}
except Exception as exp:
try:
err = exp.body
return {"message": "ERROR", "code": err["code"]}
except:
return {"message": "ERROR"}
def getDwollaCustomer(account_url):
app_key = 'PNQRGggoMwGefS97PGFBt44KO6cGM21pUwiSql9oxptYCIatMs'
app_secret = 'NToE2JWlzY0z8m6t0QYNxZ9hZgkBleSrQVntYWJd6z0gUvpYdp'
client = dwollav2.Client(key=app_key,
secret=app_secret,
environment='sandbox')
app_token = client.Auth.client()
full_account_url = 'https://api-sandbox.dwolla.com/accounts/' + str(
account_url)
print('FULL ACCOUNT URL: ' + str(full_account_url))
account = app_token.get(full_account_url)
account.body['name']
print('ACCOUNT: ' + str(account.body))
return account.body
def dwolla_payment(request):
data = {}
if request.method == "POST":
client = dwollav2.Client(key=settings.DWOLLA_KEY,
secret=settings.DWOLLA_SECRET,
environment=settings.DWOLLA_ENV
) # optional - defaults to production
app_token = client.Auth.client()
href = dwolla_get_account_href(app_token)
funding_resource = dwolla_get_funding_sources(app_token, href)
data["href"] = href
data["funding_resource"] = funding_resource
return render(request, "dwollaTest.html", {'data': data})
def lambda_handler(event, context):
new_email = event['new_email']
old_email = event['old_email']
try:
user = auth.get_user_by_email(old_email)
phone = user.phone_number
uid = user.uid
auth.update_user(
uid,
email=new_email,
email_verified=False)
phone = phone[2:]
item = table.get_item(
Key={
'phone': phone
}
)
item = item['Item']
client = dwollav2.Client(
key = os.environ.get('dwolla_key'),
secret = os.environ.get('dwolla_secret'),
environment = os.environ.get('dwolla_env')
)
app_token = client.Auth.client()
request_body = {
'email': new_email
}
app_token.post(item['customer_url'], request_body)
item['email'] = new_email
table.put_item(Item=item)
name = user.display_name
send_verification_email(name, old_email, new_email, uid)
return {"message" : "SUCCESS"}
except Exception as new_user_exception:
print(new_user_exception)
try:
error = new_user_exception.detail.response.content
response = json.loads(error)
error_code = response["error"]["message"]
return {"message" : error_code}
except Exception as err:
print(err)
return {"message" : "ERROR"}
def attach_funding(user):
res = api_instance.get_user(user['phone'])
data = res.json()
customer_url = data['customer_url']
checking = random_checking()
client = dwollav2.Client(key=keys['dwolla_key'],
secret=keys['dwolla_secret'],
environment=keys['dwolla_env'])
app_token = client.Auth.client()
client = boto3.resource(
'dynamodb',
region_name='us-east-1',
aws_access_key_id=keys['aws_access_key_id'],
aws_secret_access_key=keys['aws_secret_access_key'])
table = client.Table('DrackerUser')
item = table.get_item(Key={'phone': user['phone']})
item = item['Item']
funding_source = app_token.post('%s/funding-sources' % customer_url,
checking)
source_url = funding_source.headers['location']
app_token.post('%s/micro-deposits' % source_url)
#verify with micro deposits
currency = random_currency()
request_body = {
"amount1": {
"value": random_deposit(),
"currency": currency
},
"amount2": {
"value": random_deposit(),
"currency": currency
}
}
app_token.post('%s/micro-deposits' % source_url, request_body)
new_account = {
"url": source_url,
"name": random_string(5),
"institution": random_string(5)
}
data = {"default": new_account, "list": [new_account]}
item['funding_source'] = json.dumps(data)
table.put_item(Item=item)
return source_url
def __init__(self):
self.keys = json.loads((open("keys.json", "r")).read())
cred = credentials.Certificate(
"./dracker-9443c-firebase-adminsdk-gmc2g-7d48bbd323.json")
firebase_admin.initialize_app(cred)
self.dynamodb = boto3.resource(
'dynamodb',
region_name='us-east-1',
aws_access_key_id=self.keys['aws_access_key_id'],
aws_secret_access_key=self.keys['aws_secret_access_key'])
self.s3 = boto3.resource(
's3',
region_name='us-east-1',
aws_access_key_id=self.keys['aws_access_key_id'],
aws_secret_access_key=self.keys['aws_secret_access_key'])
dwollaclient = dwollav2.Client(key=self.keys['dwolla_key'],
secret=self.keys['dwolla_secret'],
environment=self.keys['dwolla_env'])
self.dwolla = dwollaclient.Auth.client()
def run(json_input, context):
print(json_input)
message_data = [
record["Sns"]["MessageAttributes"] for record in json_input["Records"]
]
for message in message_data:
payer_id = message["PayerIdentifier"]["Value"]
funding_source = message["PayerFundingSource"]["Value"]
performer_id = message["PerformerIdentifier"]["Value"]
payment_amount = int(message["PaymentAmount"]["Value"])
# TODO: Record this somewhere.
print("%s pays %s $%.2f" %
(payer_id, performer_id, payment_amount / 100))
client = dwollav2.Client(key=os.environ['DWOLLA_APP_KEY'],
secret=os.environ['DWOLLA_APP_SECRET'],
environment='sandbox')
app_token = client.Auth.client()
# Send Transaction
request_body = {
'_links': {
'source': {
'href': funding_source
},
'destination': {
'href':
__dwolla_url('accounts',
os.environ['DWOLLA_PAYMENT_DESTINATION'])
}
},
'amount': {
'currency': 'USD',
'value': "%.2f" % payment_amount / 100
},
'metadata': {}
}
transfer = app_token.post('transfers', request_body)
return transfer.headers['location']
def send_money(amount):
with open("secrets.txt") as file:
secrets = file.read().split(",")
# Navigate to https://dashboard.dwolla.com/applications (production) or https://dashboard-sandbox.dwolla.com/applications (Sandbox) for your application key and secret.
app_key = secrets[0]
app_secret = secrets[1]
client = dw.Client(key=app_key, secret=app_secret, environment='sandbox')
app_token = client.Auth.client()
# Make sure amount is valid
if type(amount) != str or len(amount) != 4:
print("Invalid amount")
return
request_body = {
'_links': {
"self": {
"href": "https://api-sandbox.dwolla.com/sandbox-simulations",
"type": "application/vnd.dwolla.v1.hal+json",
"resource-type": "sandbox-simulation"
},
'source': {
'href':
f'https://api-sandbox.dwolla.com/funding-sources/{secrets[2]}'
},
'destination': {
'href':
f'https://api-sandbox.dwolla.com/funding-sources/{secrets[3]}'
}
},
'amount': {
'currency': 'USD',
'value': amount
}
}
transfer = app_token.post('transfers', request_body)
return transfer.headers
def initiate_transfer(payer_phone, payee_phone, amount):
transaction_payload = {}
try:
payer_resource = user_table.get_item(Key={'phone': payer_phone})
payer_item = payer_resource['Item']
payer_sources = json.loads(payer_item['funding_source'])
dest = payer_sources['default']['url']
payee_resource = user_table.get_item(Key={'phone': payee_phone})
payee_item = payee_resource['Item']
payee_sources = json.loads(payee_item['funding_source'])
source = payee_sources['default']['url']
client = dwollav2.Client(key=os.environ.get('dwolla_key'),
secret=os.environ.get('dwolla_secret'),
environment=os.environ.get('dwolla_env'))
app_token = client.Auth.client()
request_body = {
'_links': {
'source': {
'href': source
},
'destination': {
'href': dest
}
},
'amount': {
'currency': 'USD',
'value': amount
}
}
transfer = app_token.post('transfers', request_body)
res = transfer.headers['location'].split('/')
transaction_payload['transaction_id'] = res[-1]
transaction_payload['amount'] = amount
transaction_payload['email'] = payee_item['email']
transaction_payload['phone'] = payee_item['phone']
transaction_payload['bank_account'] = payee_sources['default'][
'institution'] + ' - ' + payee_sources['default']['name']
return {"message": "SUCCESS", "payload": transaction_payload}
except Exception as err:
print(err)
return {"message": "ERROR"}
def __init__(self):
env = settings.DWOLLA_ENV
if env not in ['production', 'development', 'sandbox']:
raise ValueError('Incorrect value for DWOLLA_ENV in settings.')
dwolla_id = None
dwolla_secret = None
if env == 'sandbox':
dwolla_id = settings.DWOLLA_ID_SANDBOX
dwolla_secret = settings.DWOLLA_SECRET_SANDBOX
elif env == 'production':
dwolla_id = settings.DWOLLA_ID_PROD
dwolla_secret = settings.DWOLLA_SECRET_PROD
else:
raise ValueError('Incorrect value for DWOLLA_ENV in settings.')
self.client = dwollav2.Client(
id=dwolla_id,
secret=dwolla_secret,
environment=env
)
self.app_token = self.client.Auth.client()
def test_deep2():
#Create first user
user1 = create_data()
res = api_instance.new_user(user1)
data = res.json()
user1['uid'] = data['uid']
#Create second user
user2 = create_data()
res = api_instance.new_user(user2)
data = res.json()
user2['uid'] = data['uid']
#Wait for DynamoDB resources to be created
time.sleep(5)
transaction, res = api_instance.create_transaction(user1, user2)
transaction_id = sanatize(res.text)
#Attach a bank account
source1 = attach_funding(user1)
source2 = attach_funding(user2)
res = api_instance.settle_transaction(user1['uid'], user2['uid'],
transaction_id)
response_status = sanatize(res.text)
if response_status == "200":
print("Settle Transaction: Test Passed!")
else:
print("Settle Transaction: Test Failed!")
#Cleanup dwolla
client = dwollav2.Client(key=keys['dwolla_key'],
secret=keys['dwolla_secret'],
environment=keys['dwolla_env'])
app_token = client.Auth.client()
request_body = {'removed': True}
app_token.post(source1, request_body)
app_token.post(source2, request_body)
#CleanUp
clean_data(user1['uid'], user1['phone'])
clean_data(user2['uid'], user2['phone'])
def __init__(self):
self.rs = settings.REDIS_DB
self.mode = settings.DWOLLA_API_MODE
if self.mode not in ['PROD', 'DEV']:
raise ValueError('Dwolla API mode should be "PROD" or "DEV"')
environment = 'sandbox' if self.mode == 'DEV' else 'production'
self.client_id = getattr(settings, 'DWOLLA_ID_{}'.format(self.mode))
self.client_secret = getattr(settings,
'DWOLLA_SECRET_{}'.format(self.mode))
# Recepient Donkies LLC bank account's email.
self.donkies_email = getattr(
settings, 'DONKIES_DWOLLA_EMAIL_{}'.format(self.mode))
self.client = dwollav2.Client(id=settings.DWOLLA_ID_SANDBOX,
secret=settings.DWOLLA_SECRET_SANDBOX,
environment='sandbox')
# self.client_id,
# self.client_secret,
# environment
self.token = self.client.Auth.client()
def lambda_handler(event, context):
try:
phone = event['phone']
url = event['url']
client = dwollav2.Client(key=os.environ.get('dwolla_key'),
secret=os.environ.get('dwolla_secret'),
environment=os.environ.get('dwolla_env'))
app_token = client.Auth.client()
request_body = {'removed': True}
app_token.post(url, request_body)
item = table.get_item(Key={'phone': phone})
table_row = item['Item']
data = json.loads(table_row['funding_source'])
sources = []
for item in data["list"]:
if item["url"] != url:
sources.append(item)
data["list"] = sources
table_row['funding_source'] = json.dumps(data)
table.put_item(Item=table_row)
return {"message": "SUCCESS"}
except Exception as err:
print(err)
return {"message": "ERROR"}
def create_dwolla_entry(first, last, email, street, city, state, zipcode, ssn,
birthdate):
client = dwollav2.Client(key=os.environ.get('dwolla_key'),
secret=os.environ.get('dwolla_secret'),
environment=os.environ.get('dwolla_env'))
app_token = client.Auth.client()
request_body = {
'firstName': first,
'lastName': last,
'email': email,
'type': 'personal',
'address1': street,
'city': city,
'state': state,
'postalCode': zipcode,
'dateOfBirth': birthdate,
'ssn': ssn
}
try:
customer = app_token.post('customers', request_body)
customer_url = customer.headers['location']
return {"message": "SUCCESS", "customer_url": customer_url}
except Exception as exp:
return {"message": 'ERROR'}
import dwollav2
import os
import json
import urllib.request
from dotenv import load_dotenv
load_dotenv()
client = dwollav2.Client(
key=os.environ['DWOLLA_APP_KEY'],
secret=os.environ['DWOLLA_APP_SECRET'],
environment='sandbox', # defaults to 'production'
)
app_token = client.Auth.client()
# https://docs.dwolla.com/#create-a-funding-source-for-an-account
# creating funding source for JAMIIE
# https://docs.dwolla.com/#idempotency-key
# To prevent multiple post req
headers = {'Idempotency-Key': '19051a62-3403-11e6-ac61-9e71128cae77'}
def owner_acc_details():
r = app_token.get('/')
indented_json = json.dumps(r.body,
indent=4,
separators=(',', ': '),
sort_keys=True)
print(indented_json)
print(r.body['_links']['account']['href'])
def __init__(self):
self.client = dwollav2.Client(key=app_key,
secret=app_secret,
environment='sandbox')
self.app_token = self.client.Auth.client()
def test_sets_id_and_key_when_id_provided(self):
client = dwollav2.Client(id=self.id, secret=self.secret)
self.assertEqual(self.id, client.id)
self.assertEqual(self.id, client.key)
def test_api_url(self):
client = dwollav2.Client(id=self.id, secret=self.secret)
self.assertEqual(client.ENVIRONMENTS[client.environment]['api_url'],
client.api_url)
def test_sets_on_grant(self):
on_grant = lambda x: x
client = dwollav2.Client(id=self.id,
secret=self.secret,
on_grant=on_grant)
self.assertEqual(on_grant, client.on_grant)
def test_raises_if_invalid_environment(self):
with self.assertRaises(ValueError):
dwollav2.Client(id=self.id,
secret=self.secret,
environment='invalid')
def test_sets_environment(self):
client = dwollav2.Client(id=self.id,
secret=self.secret,
environment='sandbox')
self.assertEqual('sandbox', client.environment)
