def connect(plaid_credentials, bank, bank_credentials):
client = Client(client_id=plaid_credentials.client_id, secret=plaid_credentials.secret)
try:
response = client.connect(bank, {
'username': bank_credentials.username,
'password': bank_credentials.password
})
data = json.loads(response.content)
if response.status_code == 200:
print data
if "access_token" in data:
client_access_token = data["access_token"]
client = Client(client_id=plaid_credentials.client_id, secret=plaid_credentials.secret, access_token=client_access_token)
response = client.connect_get()
data = json.loads(response.content)
with open("tx.json", "w") as f:
f.write(json.dumps(data))
else:
print "Something went horribly wrong..."
print data
except plaid_errors.UnauthorizedError as e:
# handle this
print e
def requestTransactions(self):
if "token" not in self.credentials["plaid"]:
client = Client(client_id=self.credentials["plaid"]["client"],
secret=self.credentials["plaid"]["secret"])
data = ""
try:
response = client.connect(self.bank, {
'username': self.login,
'password': self.password
})
data = response.json()
except plaid_errors.UnauthorizedError as e:
print("AHHH")
print(e.message)
exit()
token = data['access_token']
self.credentials["plaid"]["token"] = token
client = Client(client_id=self.credentials["plaid"]["client"],
secret=self.credentials["plaid"]["secret"],
access_token=self.credentials["plaid"]["token"])
if self.debug == True:
options = {'pending': True, 'gte': '2017/01/01'}
else:
options = {'pending': True, 'gte': self.gte}
response = client.connect_get(opts=options)
self.data = response.json()
def create_client():
'''Create a new client for testing.'''
return Client(client_id=os.environ['CLIENT_ID'],
secret=os.environ['SECRET'],
environment='sandbox',
api_version="2019-05-29",
client_app="plaid-python-unit-tests")
def setUp(self):
"""Initialization for the test cases
This is executed prior to each test.
"""
application.config['TESTING'] = True
application.config['WTF_CSRF_ENABLED'] = False
application.config['DEBUG'] = False
self.app = application.test_client()
# setup plaid client
self.client = Client(ENV_VARS["PLAID_CLIENT_ID"],
ENV_VARS["PLAID_SECRET"],
ENV_VARS["PLAID_PUBLIC_KEY"], "sandbox")
self.public_token = sandbox.PublicToken(self.client)
db.drop_all()
db.create_all()
# Create a test user and test plaid item
self.test_user = classes.User(first_name="first",
last_name="last",
email="*****@*****.**",
phone="9876543210",
password="******")
db.session.add(self.test_user)
db.session.commit()
self.test_item = classes.PlaidItems(user=self.test_user,
item_id="item",
access_token="token")
db.session.add(self.test_item)
db.session.commit()
def test_institution():
client = Client('test_id', 'test_secret')
response = client.institution(
to_json(client.institutions())[0]['id']
)
assert response.status_code == 200
def create_client():
'''Create a new client for testing.'''
return Client(os.environ['CLIENT_ID'],
os.environ['SECRET'],
os.environ['PUBLIC_KEY'],
'sandbox',
api_version="2017-03-08")
def __init__(self, cache: Path = PLAID_CACHE, **kwargs) -> None:
"""
cache: File to read/write transaction data from
kwargs:
CLIENT_ID
SECRET
PUBLIC_KEY
ENV
CHASE_TOKEN
"""
self._CLIENT_ID = kwargs.get("CLIENT_ID", CLIENT_ID)
self._SECRET = kwargs.get("SECRET", SECRET)
self._PUBLIC_KEY = kwargs.get("PUBLIC_KEY", PUBLIC_KEY)
self._ENV = kwargs.get("ENV", ENV)
self._CHASE_TOKEN = kwargs.get("CHASE_TOKEN", CHASE_TOKEN)
self._client = Client(
self._CLIENT_ID, self._SECRET, self._PUBLIC_KEY, self._ENV
)
self._end_date = datetime.date.today().isoformat()
self._get_chase_transactions = partial(
self._client.Transactions.get, self._CHASE_TOKEN
)
self.cache = cache
self._read()
def plaidclient():
config = {
'client_id': settings.PLAID_CLIENT_ID,
'secret': settings.PLAID_SECRET,
'environment': settings.PLAID_ENV
}
return Client(**config)
def load_statements_line_from_plaid(
self,
id_plaid='584f8ac239361943b6a40c2f',
id_secret='2eb94d1cfb298020b6d4c1e396eb75',
access_token='test_bofa'):
# get transactions
_logger.warning('\n\n\n Respuesta1: \n \n\n\n')
client = Client(client_id=id_plaid,
secret=id_secret,
access_token='test_bofa')
#PARA DELIMITAR CON FECFA response = client.connect_get(opts={'gte':'2014-06-01'}).json()
response = client.connect_get().json()
accounts = client.auth_get().json()
#transactions = response.json()
_logger.info('\n\n\n transaccion: \n %s \n\n\n' %
response['transactions'][0])
_logger.info('\n\n\n Numero de Cuenta: \n %s \n\n\n' %
accounts['accounts'][2]['numbers']['account'])
_logger.info('\n\n\n id de la cuenta: \n %s \n\n\n' %
accounts['accounts'][2]['_id'])
_logger.info('\n\n\n id de la Cuenta en la transaccion: \n %s \n\n\n' %
response['transactions'][0]['_account'])
_logger.info('\n\n\n Monto de la transaccion: \n %s \n\n\n' %
response['transactions'][0]['amount'])
_logger.info('\n\n\n fecha de la transaccion: \n %s \n\n\n' %
response['transactions'][0]['date'])
_logger.info(
'\n\n\n nombre del partner que realiza transaccion: \n %s \n\n\n' %
response['transactions'][0]['name'])
#for account in accounts['accounts']:
values = []
for resp in response['transactions']:
values.append((0, 0, {
'name': resp['name'],
'ref': resp['_id'],
'amount': resp['amount'],
'date': resp['date']
}))
#OBSOLETO
#new_id = self.env['account.bank.statement'].create({'name':"Prueba5", 'journal_id':6, 'line_ids': [(0,0,{'name': 'pruebaline', 'ref': '00002-line', 'amount': 100})]})
#new_id = self.env['account.bank.statement'].create({'name':"Prueba5", 'journal_id':6, 'line_ids': [(0,0,{'name': response['transactions'][0]['name'],
# 'ref': response['transactions'][0]['_id'],
# 'amount': response['transactions'][0]['amount'],
# 'date': response['transactions'][0]['date']
# })]})
#
new_id = self.env['account.bank.statement'].create({
'name': "Prueba5",
'journal_id': 6,
'line_ids': values
})
return True
def __init__(self, subscriptions_table_filename,
plaid_credentials_filename, bank_credentials_filename):
self.subscriptions_table = pd.read_csv(subscriptions_table_filename)
with open(plaid_credentials_filename, 'r') as f:
self.client = Client(**json.load(f), environment='development')
with open(bank_credentials_filename, 'r') as f:
self.access_token = json.load(f)['access_token']
self.client.Auth.get(self.access_token)
def create_client():
'''Create a new client for testing.'''
return Client(os.environ['CLIENT_ID'],
os.environ['SECRET'],
os.environ['PUBLIC_KEY'],
'sandbox',
api_version="2019-05-29",
client_app="plaid-python-unit-tests")
def get(self, user):
userData = User.get(User.username == user)
userData = model_to_dict(userData)
access_token = userData['accessToken']
#print(access_token)
client = Client(client_id=id, secret=secret, access_token=access_token)
transactions = client.connect_get().json()
return transactions
def test_connect_mfa_list():
client = Client('test_id', 'test_secret')
# These credentials erroneously still force mfa in the sandbox
# Should disambiguate by disallowing institution on API level
# for this particular calling
response = client.connect('chase', no_mfa_credentials)
assert response.status_code == 201
assert to_json(response)['type'] == 'list'
def test_connect_step_device_email():
client = Client('test_id', 'test_secret', access_token='test_chase')
response = client.connect_step('chase', None, options={
'send_method': {'type': 'email'}
})
assert response.status_code == 201
assert to_json(response)['type'] == 'device'
assert to_json(response)['mfa']['message'] == 'Code sent to [email protected]'
def get(self, user):
userData = User.get(User.username == user)
userData = model_to_dict(userData)
access_token = userData['accessToken']
#print(access_token)
client = Client(client_id=id, secret=secret, access_token=access_token)
balance = client.balance().json()
return balance
def __init__(self, client_id=None, secret=None):
if client_id and secret:
self.client_id = client_id
self.secret = secret
else:
self.client_id, self.secret = cm.get_plaid_config()
self.client = Client(self.client_id, self.secret, "development", suppress_warnings=True)
def test_ResourceNotFound_categories_with_suppressed_error():
Client.config({'suppress_http_errors': True})
client = Client('test_id', 'test_secret')
response = client.category('pnc')
assert response.status_code == 404
assert (
json.loads(response.content)['message'] == 'unable to find category'
)
def get(self, user):
userData = User.get(User.username == user)
userData = model_to_dict(userData)
access_token = userData['accessToken']
#print(access_token)
client = Client(client_id=id, secret=secret, access_token=access_token)
#client.upgrade('info')
info = client.info_get().json()
return info
def get_transactions():
print('Which bank shall we pull transactions from?')
bank = choices(banks)
print('Please select the appropriate account:')
account = choices(bank['accounts'])
start_date = input("input a start date 'YYYY-MM-DD': ")
end_date = input("input an end date 'YYYY-MM-DD': ")
client = Client(client_id='5850e87d3936192710fb73fc',
secret='7c1a63bbe4fb6ddac2fb555244de05',
environment='development')
response = client.Transactions.get(bank['token'],
start_date=start_date,
end_date=end_date)
transactions = response['transactions']
# the transactions in the response are paginated, so make multiple calls while increasing the offset to
# retrieve all transactions
while len(transactions) < response['total_transactions']:
response = client.Transactions.get(bank['token'],
start_date=start_date,
end_date=end_date,
offset=len(transactions))
transactions.extend(response['transactions'])
upload = ''
display_title_bar()
while upload.upper() != 'Y' and upload.upper() != 'N':
upload = input(
"Would you like to upload these transactions to Manager? [Y/N]: ")
if upload.upper() == 'Y':
for transaction in tqdm(transactions):
if transaction['account_id'] == account['id']:
if transaction['amount'] < 0:
trans_type = 'Receipt'
else:
trans_type = 'Payment'
date = transaction['date']
bank_account = bank['manager_account']
description = transaction['name']
amount = abs(transaction['amount'])
data = receipts_payments(trans_type, date, bank_account,
description, amount)
r = s.post(url + '699401fe-23fd-4b52-9699-b88b36fa6b26',
data=json.dumps(data))
if r.status_code == 201:
tqdm.write('Success!')
else:
tqdm.write(
f'Something went wrong. Error: {r.status_code}')
tqdm.write(json.dumps(data))
else:
pass
elif upload.upper() == 'N':
display_title_bar()
print('Very well, the transactions will not be uploaded')
else:
display_title_bar()
print('The choice selected was not recognized. Try again.')
def get_plaid_client():
Client.config({
'url': settings.PLAID_API_URL
})
return Client(
client_id=settings.PLAID_CLIENT_ID,
secret=settings.PLAID_CLIENT_SECRET
)
def use_token(self, username):
obj = SQLConnection()
token = obj.get_plaid_token(username)
self.client = Client(client_id='57cccae6cfbf49f67b01fd5a',
secret='2c13981884395fc691fda11148ed67',
access_token=token)
response = self.client.connect_get(token)
self.plaid_results = response.content
return response.content
def exchangeToken(publicToken):
#Takes sandbox secret
client = Client(client_id='5b343307c323c00011448c73',
secret='1960ae345a207270c000ecf9698019',
public_key=publicToken,
environment='sandbox')
exchangeResponse = client.Item.public_token.exchange(publicToken)
print('ACCESS TOKEN: ' + exchangeResponse['access_token'])
return exchangeResponse
def create_account(account):
try:
_create_directory_tree(FILE_DEFAULTS.config_file)
config = configparser.ConfigParser(interpolation=None)
config[account] = OrderedDict()
plaid = config[account]
client_id, secret = get_plaid_config()
# client_id = prompt('Enter your Plaid client_id: ', validator=NullValidator())
# plaid['client_id'] = client_id
# secret = prompt('Enter your Plaid secret: ', validator=NullValidator())
# plaid['secret'] = secret
configs = {
'user': {
'client_user_id': '123-test-user-id',
},
'products': ['transactions'],
'client_name': "Plaid Test App",
'country_codes': ['US'],
'language': 'en',
}
# create link token
client = Client(client_id, secret, "development", suppress_warnings=True)
response = client.LinkToken.create(configs)
link_token = response['link_token']
generate_auth_page(link_token)
print("\n\nPlease open " + FILE_DEFAULTS.auth_file + " to authenticate your account with Plaid")
public_token = prompt('Enter your public_token from the auth page: ', validator=NullValidator())
# plaid['public_token'] = public_token
response = client.Item.public_token.exchange(public_token)
access_token = response['access_token']
plaid['access_token'] = access_token
item_id = response['item_id']
plaid['item_id'] = item_id
response = client.Accounts.get(access_token)
accounts = response['accounts']
print("\n\nAccounts:\n")
for item in accounts:
print(item['name'] + ":")
print(item['account_id'])
account_id = prompt('\nEnter account_id of desired account: ', validator=NullValidator())
plaid['account'] = account_id
except plaid_errors.ItemError as ex:
print(" %s" % ex, file=sys.stderr )
sys.exit(1)
else:
with open(FILE_DEFAULTS.config_file, mode='a') as f:
config.write(f)
return True
def __init__(self):
env = settings.PLAID_ENV
if env not in ['production', 'development', 'sandbox']:
raise ValueError('Incorrect value for PLAID_ENV in settings.')
self.client = Client(
client_id=settings.PLAID_CLIENT_ID,
secret=settings.PLAID_SECRET,
public_key=settings.PLAID_PUBLIC_KEY,
environment=env)
def __init__(self,
client_id=None,
secret=None,
account_id=None,
access_token=None):
if client_id and secret:
self.client_id = client_id
self.secret = secret
else:
self.client_id, self.secret = cm.get_plaid_config()
self.client = Client(client_id=self.client_id, secret=self.secret)
def get_plaid_client():
try:
client = Client(client_id=PLAID_CLIENT_ID,
secret=PLAID_SECRET_KEY,
public_key=PLAID_PUBLIC_KEY,
environment=PLAID_ENV)
return client
except Exception as e:
logger.error(
'Exception raised when trying to create Plaid client. Exception: {}'.format(e))
raise Exception("Error creating Plaid client")
def __init__(self):
"""
Initializes an instance.
NOTE: We don't use the Lazy pattern here because the Plaid Client caches access tokens between method calls.
"""
self._client = Client(
client_id=os.environ["PLAID_CLIENT_ID"],
secret=os.environ["PLAID_SECRET"],
public_key=os.environ["PLAID_PUBLIC_KEY"],
environment=os.environ["PLAID_ENV"],
)
def getTransaction(accessToken, startDate, endDate):
publicToken = '707d6df9798a9bf35257173c18e86b'
client = Client(client_id='5b343307c323c00011448c73',
secret='1960ae345a207270c000ecf9698019',
public_key=publicToken,
environment='sandbox')
transactionResponse = client.Transactions.get(accessToken,
start_date=startDate,
end_date=endDate)
transactions = transactionResponse['transactions']
return transactions
def account_data(plaid_access_token):
# Returns all account data for plaid_access_token account
from plaid import Client
client = Client(client_id='5a54dbbdefe64e49ca4ae233', secret='e46141f14d9a73d68f2dc58a7a9c3b',
public_key='cc5eca9a7b42c6fd2dee4ebad4e959', environment='sandbox')
# Retrieve Auth information for the Item, which includes high-level
# account information and account numbers for depository accounts.
auth_response = client.Auth.get(plaid_access_token)
return auth_response
def create_client():
'''Create a new client for testing.'''
if SESSION_MANAGER['session'] is None or SESSION_MANAGER['session'].closed:
print('Opening aio http session!')
SESSION_MANAGER['session'] = aiohttp.ClientSession()
return Client(os.environ['CLIENT_ID'],
os.environ['SECRET'],
os.environ['PUBLIC_KEY'],
'sandbox',
SESSION_MANAGER['session'],
api_version="2019-05-29",
client_app="plaid-python-unit-tests")
