def seed_trades():
trade1 = Trade(traderId=1,
makerCurrencyId=2,
takerCurrencyId=1,
quantity=190,
bidOrOffer="bid",
price=1.5764,
created_on="5/5/2021",
postId=1,
uniqueTradeId='0abeb50c-b2b7-11eb-b0c2-acde48001122')
trade2 = Trade(traderId=2,
makerCurrencyId=3,
takerCurrencyId=1,
quantity=190,
bidOrOffer="offer",
price=1.5764,
created_on="5/5/2021",
postId=1,
uniqueTradeId='0abeb50c-b2b7-11eb-b0c2-acde48001123')
trade3 = Trade(traderId=1,
makerCurrencyId=2,
takerCurrencyId=1,
quantity=510,
bidOrOffer="bid",
price=1.6964,
created_on="5/4/2021",
postId=6,
uniqueTradeId='0abeb50c-b2b7-11eb-b0c2-acde48001124')
trade = [trade1, trade2, trade3]
db.session.add_all(trade)
db.session.commit()
def make_trade(offer_b, offer_s):
print("MAKING TRADE ON:", offer_b, offer_s)
price_for_item_b = get_item_price(offer_b)
price_for_item_s = get_item_price(offer_s)
# If buy user's inventory doesn't exist - create
if not Inventory.objects.filter(user=offer_b.user,
item=offer_b.item).exists():
inv = Inventory(user=offer_b.user, item=offer_b.item, amount=0)
inv.save()
amount = offer_b.amount if offer_b.amount <= offer_s.amount else offer_s.amount
total_price = amount * get_item_price(offer_s)
# Making trade
trade = Trade(item=offer_b.item, amount=amount, price=total_price, \
seller=offer_s.user, seller_offer=offer_s, buyer=offer_b.user, \
buyer_offer=offer_b)
# Offers & inventories amount actions
offer_b.amount -= amount
offer_s.amount -= amount
# Changing inventory amount
inventory_b = get_object_or_404(Inventory,
user=offer_b.user,
item=offer_b.item)
inventory_s = get_object_or_404(Inventory,
user=offer_s.user,
item=offer_s.item)
inventory_s.amount -= amount
inventory_b.amount += amount
# Money actions
money_action(offer_b.user, amount, "-")
money_action(offer_s.user, amount, "+")
# Check if offer is closed
if offer_b.amount == 0:
offer_b.is_active = False
if offer_s.amount == 0:
offer_s.is_active = False
offer_b.price = offer_b.amount * price_for_item_b
offer_s.price = offer_s.amount * price_for_item_s
# Saving all data
trade.save()
offer_b.save()
offer_s.save()
inventory_b.save()
inventory_s.save()
def makeTrade(userId):
if method == "POST":
data = request.json
timestamp = datetime.datetime.utcnow()
newTrade = Trade(ticker=data["ticker"],
price=data["price"],
shares=round(int(data["shares"]), 2),
buy=data["buy"],
buyDate=timestamp,
userId=userId)
currentStock = Stock.query.filter(
Stock.ticker == data["ticker"]).first()
if not currentStock:
newStock = Stock(ticker=data['ticker'])
db.session.add(newStock)
db.session.commit()
currentStock = Stock.query.filter(
Stock.ticker == data["ticker"]).first()
stockId = currentStock.id
currentlyOwned = Stocklist.query.filter(
Stocklist.stockId == stockId).filter(
Stocklist.userId == userId).first()
currentShares = 0 if not currentlyOwned else float(
currentlyOwned.shares)
newShares = float(data["shares"]) * (1 if data["buy"] else -1)
updatedShares = round((currentShares + newShares), 2)
currentUser = User.query.filter(User.id == userId).first()
currentBalance = float(currentUser.balance)
cost = round((float(data["shares"]) * float(data["price"])) *
(1 if data["buy"] else -1), 2)
updatedBalance = round((currentBalance - cost), 2)
if updatedShares < 0:
return {"error": "You can't have negative shares"}
if updatedBalance < 0:
return {"error": "You can't have a negative balance"}
if currentlyOwned:
currentlyOwned.shares = updatedShares
else:
currentlyOwned = Stocklist(stockId=stockId,
userId=userId,
shares=updatedShares)
currentUser.balance = updatedBalance
db.session.add(newTrade)
db.session.add(currentlyOwned)
db.session.add(currentUser)
db.session.commit()
all_stocks = Stocklist.query.filter(Stocklist.userId == userId).all()
# return in format {ticker: shares}
return {
"stocks":
list({
Stock.query.filter(Stock.id == stock.stockId).first().ticker:
str(stock.shares)
} for stock in all_stocks)
}
def parse_trades(db_ticker):
ticker = db_ticker.symbol
log.info(f'Trades parsing for {ticker}')
last_page_detected = False
last_page = 10
page_num = 1
while page_num <= last_page:
resp = requests.get(
f'http://www.nasdaq.com/symbol/{ticker.lower()}/insider-trades?page={page_num}'
)
page_num += 1
soup = bs4.BeautifulSoup(resp.text, 'html.parser')
if not last_page_detected:
last_page = get_last_page(soup)
last_page_detected = True
div = soup.find("div", {"class": "genTable"})
trs = div.find_all('tr')[1:]
for tr in trs:
tds = tr.find_all("td")
insider_name = tds[0].find("a").text.upper().strip()
insider = Insider.get_or_create(name=insider_name)[0]
last_date = datetime.strptime(tds[2].text.strip(),
'%m/%d/%Y').date()
last_price = to_float(tds[6].text)
Trade.get_or_create(
insider=insider,
last_date=last_date,
transaction_type=tds[3].text.strip(),
owner_type=tds[4].text.strip(),
shares_trades=to_float(tds[5].text),
last_price=last_price,
shares_held=to_float(tds[7].text),
ticker=db_ticker,
)
def add_trade():
if 'username' not in session:
return redirect(url_for('index'))
receive = request.get_json()
xml = receive['info']
# cursor = con.cursor() # ?get_db无效
# cursor.execute('insert into trade (tradeinfo) VALUES (%s)', xml)
# con.commit()
# cursor.close()
trade = Trade(info=xml)
db.session.add(trade)
db.session.commit()
trade.update_xml()
db.session.commit()
return jsonify({'msg': 'success', 'id': trade.id})
async def get_insider(db_manager, ticker, insider_name):
db_ticker = await db_manager.get(Ticker, symbol=ticker)
insider = await db_manager.get(Insider, name=insider_name)
trades = await db_manager.execute(Trade.select().where(
Trade.ticker == db_ticker,
Trade.insider == insider).order_by(Trade.last_date.desc()))
trades = [t.as_json() for t in trades]
log.debug(f'Result for ticker {ticker}, insider {insider_name}.')
return trades
async def get_trades(db_manager, ticker):
ticker_db = await db_manager.get(Ticker, symbol=ticker)
trades = await db_manager.execute(
Trade.select(Trade, Insider).join(Insider).where(
Trade.ticker == ticker_db).order_by(Trade.last_date.desc()))
result = []
for trade in trades:
new_trade = trade.as_json()
new_trade['insider'] = trade.insider.name
result.append(new_trade)
log.debug(f'Trades for {ticker}: {trades}.')
return result
def trade():
user = current_user
balances = Balance.query.filter_by(user_id=user.id).first()
form = TradeForm()
if form.validate_on_submit():
tx_type = form.option.data
amount = form.btc_amount.data
try:
price = session['price']
total = price * amount
# session.pop('price', None)
except KeyError:
price = 'N/A'
total = 'N/A'
print("Amount: ", amount)
print("Price: ", price)
print("Total: ", total)
if all(isinstance(i, float) for i in [amount, price, total]):
if (tx_type == 'Buy' and balances.balance_usd >= total) or \
(tx_type == 'Sell' and balances.balance_btc >= amount):
if tx_type == 'Buy':
new_balance_btc = balances.balance_btc + amount
new_balance_usd = balances.balance_usd - total
else:
new_balance_btc = balances.balance_btc - amount
new_balance_usd = balances.balance_usd + total
db.session.delete(balances)
db.session.commit()
trade = Trade(tx_type=tx_type,
amount=amount,
price=price,
total=total,
user_id=user.id)
new_balances = Balance(balance_btc=new_balance_btc,
balance_usd=new_balance_usd,
user_id=user.id)
db.session.add_all([trade, new_balances])
db.session.commit()
balances = Balance.query.filter_by(user_id=user.id).first()
flash('Your {} trade was executed - {} BTC @ ${}'.format(
tx_type.lower(), clean(amount), clean(price)))
else:
flash('Your {} trade failed - insufficient funds'.format(
tx_type.lower()))
else:
return redirect(url_for('trade'))
return render_template('trade.html',
user=user,
balances=balances,
form=form)
def trade():
'''Goes through all the necessary interactions that must happen when a trade request is made.'''
if len(current_user.cards) == 0:
flash('You do not have any cards to trade!', 'danger')
return redirect(url_for('user.trades'))
if 'first_card' in request.form.keys(
) and 'second_card' in request.form.keys():
flash('Your trade has been posted!', 'success')
from app import app
with app.app_context():
t = Trade(request.form['second_card'], request.form['first_card'],
current_user.id)
db.session.add(t)
db.session.commit()
return redirect(url_for('user.trades'))
return render_template('trade.html', query=Card.query)
def create_test_trade() -> Trade:
trade: Trade = Trade()
trade.ticker = "TSLA"
trade.type = TradeType.LONG
trade.stop_price = 380
executions: List[Execution] = []
executions.append(
create_execution(ExecutionType.BUY, 200, 400,
datetime(2017, 11, 28, 23, 55, 59, 0)))
executions.append(
create_execution(ExecutionType.BUY, 200, 420,
datetime(2017, 11, 20, 23, 55, 59, 0)))
executions.append(
create_execution(ExecutionType.SELL, 100, 460,
datetime(2017, 11, 28, 23, 55, 59, 0)))
trade.executions = executions
print(str(trade))
return trade
def trade():
if request.method == 'GET':
trades = Trade.query.all()
result = trades_schema.dump(trades)
return jsonify(result)
elif request.method == 'POST':
currency = request.form.get('currency')
quantity = request.form.get('quantity')
direction = request.form.get('direction')
trade = Trade(currency, quantity, direction)
db.session.add(trade)
db.session.commit()
result = trade_schema.dump(trade)
return jsonify(result)
else:
return 'Err: Bad Request for /trades'
def newTrade():
try:
tradeData = request.json
#? Trade ingredients
makerId = tradeData['makerId']
takerId = current_user.id
makerCurrencyId = tradeData['postedCurrencyId']
takerCurrencyId = tradeData['postedCurrencyId']
quantity = tradeData['quantity']
makerDirection = tradeData['makerDirection']
price = tradeData['price']
postId = tradeData['postId']
baseQuantity = tradeData['tradeQuantity']
date = tradeData['date']
baseCurrencyId = SingleCurrency.query.filter(
SingleCurrency.name ==
tradeData['baseName']).first().to_dict()['id']
baseCurrencyName = tradeData['baseName']
quoteCurrencyId = SingleCurrency.query.filter(
SingleCurrency.name ==
tradeData['quoteName']).first().to_dict()['id']
quoteCurrencyName = tradeData['quoteName']
#! the api I was using now requires an apikey that grants very few api calls, while I search for a new api/creating an account, I am using a single static rate for all currencies.
# quoteQuantity = c.convert(
# baseQuantity, f'{baseCurrencyName}', f'{quoteCurrencyName}')
quoteQuantity = price * baseQuantity
uniqueTradeId = uuid.uuid1()
if makerDirection == 'offer':
takerDirection = 'bid'
#Subtract trade quantity from the balance of maker
makerBaseBalance = UserBalance.query.filter(
and_(UserBalance.userId == makerId,
UserBalance.currencyId == baseCurrencyId)).first()
makerQuoteBalance = UserBalance.query.filter(
and_(UserBalance.userId == makerId,
UserBalance.currencyId == quoteCurrencyId)).first()
makerBaseBalance.quantity = makerBaseBalance.quantity - baseQuantity
makerQuoteBalance.quantity = makerQuoteBalance.quantity + quoteQuantity
#Add trade quantity to the balance of taker
takerBaseBalance = UserBalance.query.filter(
and_(UserBalance.userId == takerId,
UserBalance.currencyId == baseCurrencyId)).first()
takerQuoteBalance = UserBalance.query.filter(
and_(UserBalance.userId == takerId,
UserBalance.currencyId == quoteCurrencyId)).first()
takerBaseBalance.quantity = takerBaseBalance.quantity + baseQuantity
takerQuoteBalance.quantity = takerQuoteBalance.quantity - quoteQuantity
# commit both changes to the user Balance
db.session.commit()
#Create new trades for both the maker and taker
makerTrade = Trade(makerCurrencyId=makerCurrencyId,
takerCurrencyId=takerCurrencyId,
quantity=quoteQuantity,
bidOrOffer=makerDirection,
price=price,
postId=postId,
created_on=date,
traderId=makerId,
uniqueTradeId=uniqueTradeId)
takerTrade = Trade(makerCurrencyId=makerCurrencyId,
takerCurrencyId=takerCurrencyId,
quantity=baseQuantity,
bidOrOffer=takerDirection,
price=price,
postId=postId,
created_on=date,
traderId=takerId,
uniqueTradeId=uniqueTradeId)
db.session.add_all([makerTrade, takerTrade])
db.session.commit()
return {'response': 'success'}
else:
takerDirection = 'offer'
#Subtract trade quantity from the balance of maker
makerBaseBalance = UserBalance.query.filter(
and_(UserBalance.userId == makerId,
UserBalance.currencyId == baseCurrencyId)).first()
makerQuoteBalance = UserBalance.query.filter(
and_(UserBalance.userId == makerId,
UserBalance.currencyId == quoteCurrencyId)).first()
makerBaseBalance.quantity = makerBaseBalance.quantity + baseQuantity
makerQuoteBalance.quantity = makerQuoteBalance.quantity - quoteQuantity
#Add trade quantity to the balance of taker
takerBaseBalance = UserBalance.query.filter(
and_(UserBalance.userId == takerId,
UserBalance.currencyId == baseCurrencyId)).first()
takerQuoteBalance = UserBalance.query.filter(
and_(UserBalance.userId == takerId,
UserBalance.currencyId == quoteCurrencyId)).first()
takerBaseBalance.quantity = takerBaseBalance.quantity - baseQuantity
takerQuoteBalance.quantity = takerQuoteBalance.quantity + quoteQuantity
# commit both changes to the user Balance
db.session.commit()
#Create new trades for both the maker and taker
makerTrade = Trade(makerCurrencyId=makerCurrencyId,
takerCurrencyId=takerCurrencyId,
quantity=baseQuantity,
bidOrOffer=makerDirection,
price=price,
postId=postId,
created_on=date,
traderId=makerId,
uniqueTradeId=uniqueTradeId)
takerTrade = Trade(makerCurrencyId=makerCurrencyId,
takerCurrencyId=takerCurrencyId,
quantity=baseQuantity,
bidOrOffer=takerDirection,
price=price,
postId=postId,
created_on=date,
traderId=takerId,
uniqueTradeId=uniqueTradeId)
db.session.add_all([makerTrade, takerTrade])
db.session.commit()
return {'response': 'success'}
except:
return {'response': 'failed'}