def get_api_key():
username = request.json['username']
password = util.hash_pass(request.json['password'])
account = Account.login(username, password)
if not account:
return jsonify(UNAUTHORIZED), 401
return jsonify({"api_key": account.api_key, "username": account.username})
def alltrades(api_key):
account = Account.authenticate_api(api_key)
if not account:
return jsonify({"error": "authentication error"}), 401
else:
all_trades = account.get_all_trades_json()
return jsonify({"trades": all_trades})
def trades_for(api_key, ticker):
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
trades = account.get_trades_for(ticker)
json_list = [trade.json() for trade in trades]
return jsonify({"username": account.username, "trades": json_list})
def get_equ(token):
account = Account.api_authenticate(token)
if account:
res = Position.from_position_equity(account.pk)
total = res.total_equ(account.pk)
return jsonify({'equity': total})
return jsonify({'error': 'invalid key'})
def positions(api_key):
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
positions = account.get_positions()
json_list = [position.json() for position in positions]
return jsonify({"username": account.username, "positions": json_list})
def testOnePosition(self):
account = Account(username="******",
password_hash="password",
balance=50000)
self.assertEqual(account.username, "Justin")
self.assertEqual(account.password_hash, "password")
self.assertEqual(account.balance, 50000)
self.assertIsInstance(account, Account)
def viewapikey():
if not request.json or 'username' not in request.json or 'password' not in request.json:
print(request.json)
return jsonify(BADREQUEST), 400
r = request.json
account = Account.login(r['username'], r['password'])
return jsonify({"username": account.username, "apikey": account.api_key})
def testSaveInsert(self):
caroline = Account(username="******",
password_hash="password",
balance=10000,
first_name="Caroline",
last_name="Grabowski",
email="*****@*****.**")
caroline.save()
self.assertIsNotNone(caroline.id,
"save should set an id value for new input")
with sqlite3.connect(DBPATH) as connection:
cursor = connection.cursor()
SQL = "SELECT * FROM accounts WHERE username='******';"
cursor.execute(SQL)
rows = cursor.fetchall()
self.assertEqual(len(rows), 1,
"save should create 1 new row in the database")
def testOnePosition(self):
account = Account(username="******",
password_hash="abdoulname",
balance=20000)
self.assertEqual(account.username, "Abdoul")
self.assertEqual(account.password_hash, "abdoulname")
self.assertEqual(account.balance, 20000)
self.assertIsInstance(account, Account)
def tracker_chart(api_key, ticker):
user = Account.api_authenticate(api_key)
if user:
new_user = Tracking.pk_authenticate(user.pk)
tracker = tracking_chart(ticker)
return jsonify({"tracker": tracker})
return jsonify({"error": "failed"})
def deposit(api_key, amount):
account = Account.api_authenticate(api_key)
if account:
account.balance += int(amount)
account.save()
return jsonify({"new balance": account.balance, "status": "success"})
else:
return jsonify({"error": "authentication error"})
def seed(dbpath=DBPATH):
ORM.dbpath = dbpath
mike_bloom = Account(username='******', balance=10000.00)
mike_bloom.set_password('password')
mike_bloom.api_key = '00000'
mike_bloom.save()
buy_trade = Trade(accounts_pk=mike_bloom.pk,
ticker='tsla',
volume=10,
price=100.0)
sell_trade = Trade(accounts_pk=mike_bloom.pk,
ticker='tsla',
volume=-5,
price=200.0)
buy_trade.save()
sell_trade.save()
tsla_position = Position(ticker='tsla',
shares=5,
accounts_pk=mike_bloom.pk)
appl_position = Position(ticker='aapl',
shares=5,
accounts_pk=mike_bloom.pk)
tsla_position.save()
appl_position.save()
def login():
data = request.get_json()
email = data.get("email")
password = data.get("password")
user = Account.signin(email, password)
if user:
return jsonify({"token": user.api_key})
return jsonify({"token": ""})
def look_price(api_key, ticker):
user = Account.api_authenticate(api_key)
if user:
new_user = Tracking.pk_authenticate(user.pk)
price = get_price_of_ticker(ticker)
change = day_change(ticker)
# tracker = tracking_chart(ticker)
return jsonify({'current_price': price, 'change': change})
return jsonify({"error": "failed"})
def track(ticker, api_key):
data = request.get_json()
ticker = data.get('ticker')
account = Account.api_authenticate(api_key)
if account:
new_track = Tracking(None, account.pk, ticker)
new_track.save()
return jsonify({"tracking": ticker})
return jsonify({"error": "no track added"})
def getkey():
if not request.json or 'username' not in request.json or 'password' not in request.json:
return jsonify(BAD_REQUEST), 401
account = Account.login(request.json['username'], request.json['password'])
if not account:
return jsonify(UNAUTHORIZED), 401
rdict = {'api_key': account.api_key, 'username': account.username}
print(rdict)
return jsonify(rdict)
def position_for(api_key, ticker):
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
position = account.get_position_for(ticker)
return jsonify({
"username": account.username,
"positions": position.json()
})
def positions_sum(api_key):
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
positions = account.get_positions()
tot_sum = 0
for position in positions:
tot_sum += util.get_price(position.ticker) * position.shares
return jsonify({"account_sum": tot_sum})
def setUpClass(cls):
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
db.create_all()
Role.insert_roles()
cls.acc = Account(password='******', email='*****@*****.**')
db.session.add(cls.acc)
db.session.commit()
def viewall(api_key):
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
stocks = account.getallprices()
if stocks == False:
return jsonify(NOTFOUND), 404
json_list = [allstocks for allstocks in stocks]
return jsonify({"username": account.username, "stocks": json_list})
def accounts():
accounts_dic = {}
accounts = Account.all()
for account in accounts:
accounts_dic[account.username] = {
"username": account.username,
"balance": account.balance,
"api-key": account.api_key
}
return jsonify({"accounts": accounts_dic})
def accoun_info(api_key):
account = Account.api_authenticate(api_key)
data = {}
data["balance"] = account.balance
data["username"] = account.username
return jsonify(data)
def deposit():
account = Account.api_authenticate(session['api_key'])
if not account:
return redirect(url_for('login'))
else:
if request.method == 'GET':
return render_template('deposit.html', balance=view.bal_and_pos(account.balance))
else:
amt = float(request.form['deposit_amount'])
account.deposit(amt)
return render_template('deposit.html', amt1=view.deposit_outp(amt), balance=view.bal_and_pos(account.balance))
def deposit(api_key):
if not request.json or 'amount' not in request.json:
return jsonify(BADREQUEST), 400
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
amount = request.json['amount']
account.deposit(float(amount))
account.save()
return jsonify({"username": account.username, "balance": account.balance})
def withdraw(api_key):
if not request.json or 'amount' not in request.json:
return jsonify(BAD_REQUEST), 400
account = Account.api_authenticate(api_key)
if not account:
return jsonify(UNAUTHORIZED), 401
amount = request.json['amount']
if amount < 0:
return jsonify(BAD_REQUEST), 400
account.withdraw(amount)
account.save()
return jsonify({"username": account.username, "balance": account.balance})
def position(api_key, ticker):
account = Account.authenticate_api(api_key)
if not account:
return jsonify({"error": "authentication error"}), 401
positions = account.get_positions()
for posish in positions:
if posish.ticker == ticker:
return jsonify({
"position": posish.ticker,
"shares": posish.shares
})
return jsonify({"error": "404 not found"}), 404
def login():
if not request.json or 'username' not in request.json or 'password' not in request.json:
return jsonify(BAD_REQUEST), 401
account = Account.login(request.json['username'], request.json['password'])
if not account:
return jsonify(UNAUTHORIZED), 401
token = encodeAuthToken(account.pk)
return jsonify({
'status': 'success',
'auth_token': str(token),
'api_key': account.api_key
})
def login():
if request.method == 'GET':
return render_template('login.html')
elif request.method == 'POST':
session['username'] = request.form['uname']
session['password'] = util.hash_pass(request.form['pword'])
account = Account.login(session['username'], session['password'])
if account == None:
return render_template('login.html', error=view.invalid_info())
else:
session['api_key'] = account.api_key
return render_template('dashboard.html', Username=session['username'])
def testSaveUpdate(self):
caroline = Account(username="******",
password_hash="password",
balance=10000,
first_name="Caroline",
last_name="Grabowski",
email="*****@*****.**")
caroline.save()
caroline_id = caroline.id
caroline2 = Account.from_id(caroline_id)
caroline2.username = "******"
caroline2.balance = 20000
caroline2.first_name = "Caro"
caroline2.last_name = "Grabo"
caroline2.save()
self.assertEqual(caroline2.id, caroline_id,
"update should not change ID number")
caroline3 = Account.from_id(caroline_id)
self.assertEqual(caroline3.username, "cgrabow16",
"update should update username")
self.assertEqual(caroline3.balance, 20000,
"update should update balance")
self.assertEqual(caroline3.first_name, "Caro",
"update should update name")
self.assertEqual(caroline3.last_name, "Grabo",
"update should update name")
def seed(dbpath=DBPATH):
ORM.dbpath = dbpath
mike_bloom = Account(username='******', balance=10000.00)
mike_bloom.set_password('password')
mike_bloom.save()
# trade for a purchase of 10 shares yesterday
# trade for a sell of 5 shares today
tsla_position = Position(ticker='tsla',
shares=5,
accounts_pk=mike_bloom.pk)
tsla_position.save()
ms_position = Position(ticker='ms', shares=10, accounts_pk=mike_bloom.pk)
ms_position.save()
tsla_trade = Trade(
ticker='tsla',
volume=5,
price=95.20,
time=time.time(),
accounts_pk=mike_bloom.pk,
)
tsla_trade.save()
ms_trade = Trade(
ticker='ms',
volume=10,
price=25.50,
time=time.time(),
accounts_pk=mike_bloom.pk,
)
ms_trade.save()
def __init__(self, account_id=DEFAULT_ACCOUNT_ID):
self.account = Account.get(Account.id == account_id)
self.date_range = None
