def edit(request):
try:
body = json.loads(request.body.decode('utf-8'))
user = get_user(request)
portfolio = Portfolio.objects.get(email=user.email)
for so in portfolio.get_stock_ownerships():
so.delete()
#print(body)
for s in body["stocks"]:
ticker = s["ticker"]
for t in s["transactions"]:
add_result = portfolio.add_stock(ticker, t["date"],
int(t["volume"]),
float(t["price"]))
if add_result['message'] != "Success":
print("Returned ", add_result)
return HttpResponseBadRequest(json.dumps(add_result))
for so in portfolio.get_stock_ownerships():
so.recalculate()
except Exception as e:
print(e)
raise e
return HttpResponseBadRequest()
return HttpResponse()
def metrics(request):
try:
user = get_user(request)
portfolio = Portfolio.objects.get(email=user.email)
scores = {"beta_score": 0, "profit_score": 0, "volatility_score": 0}
suggestions = []
if len(portfolio.get_stock_ownerships()) > 0:
scores["beta_score"] = round(calc_diversification_score(portfolio))
scores["profit_score"] = round(calc_profit_score(portfolio))
scores["volatility_score"] = round(
calc_volatility_score(portfolio))
suggestions.append(get_suggestions("beta", scores["beta_score"]))
suggestions.append(
get_suggestions("profit", scores["profit_score"]))
suggestions.append(
get_suggestions("volatility", scores["volatility_score"]))
responseData = {"scores": scores, "suggestions": suggestions}
return HttpResponse(json.dumps(responseData))
except Exception as e:
raise e
pass
return HttpResponseBadRequest()
def rank(request, reverse=True):
try:
n = int(request.GET.get("n"))
user = get_user(request)
portfolio = Portfolio.objects.get(email=user.email)
profit_margins = []
for stockOwnership in StockOwnership.objects.filter(owner=portfolio):
profit_margins.append({
"name":
str(stockOwnership.get_stock_name()),
"ticker":
str(stockOwnership.get_stock_ticker()),
"price":
stock_api.get_price(stockOwnership.get_stock_ticker()),
"profit_margin":
stockOwnership.calc_profit_margin()
})
profit_margins.sort(reverse=reverse,
key=lambda pm: pm["profit_margin"])
profit_margins = profit_margins[:min(len(profit_margins), n)]
ret = {"stocks": []}
ret["stocks"] = profit_margins
return HttpResponse(json.dumps(ret))
except Exception as e:
raise e
return HttpResponseBadRequest("portfolio best bad request")
return HttpResponseBadRequest("portfolio best really bad request")
def get_watchlists(request):
#get all watchlists associated with a user
user = get_user(request)
ret = {"watchlists": []}
for wl in Watchlist.objects.filter(user=user):
ret["watchlists"].append({"id": wl.id, "label": wl.name})
return HttpResponse(json.dumps(ret))
def create_watchlist(request):
body = json.loads(request.body.decode("utf-8"))
user = get_user(request)
name = body["label"]
# how do we want to handle things that have been aleady created?
wl = Watchlist.objects.create(user=user, name=name)
responseData = {"id": wl.id, "label": wl.name}
return HttpResponse(json.dumps(responseData))
def get_num_forex_calls(request):
ret = {}
user = get_user(request)
if is_admin(user):
ret = {"num_calls": ForexApiInterface.get_num_calls()}
else:
return HttpResponseForbidden()
return HttpResponse(json.dumps(ret))
def get_forex_api_priority(request):
ret = {"forex_api_priorities": []}
user = get_user(request)
if is_admin(user):
ret["forex_api_priorities"] = (
ForexApiInterface.get_ordered_forex_api_list())
else:
return HttpResponseForbidden()
return HttpResponse(json.dumps(ret))
def get_news_api_priority(request):
ret = {}
user = get_user(request)
ret = {"news_api_priorities": []}
if is_admin(user):
ret["news_api_priorities"] = (
NewsApiInterface.get_ordered_news_api_list())
else:
return HttpResponseForbidden()
return HttpResponse(json.dumps(ret))
def save_watchlist(request):
body = json.loads(request.body.decode("utf-8"))
user = get_user(request)
watchlist = body["id"]
try:
wl = Watchlist.objects.get(id=watchlist, user=user)
tickers = [x["ticker"] for x in body["tickers"]]
wl.save_stocks(set(tickers))
except Watchlist.DoesNotExist:
return HttpResponseNotFound()
return HttpResponse()
def delete_watchlist(request):
body = json.loads(request.body.decode("utf-8"))
user = get_user(request)
watchlist_id = body["id"]
try:
wl = Watchlist.objects.get(id=watchlist_id, user=user)
if wl.user != user:
return HttpResponseBadRequest("you naughty naughty")
wl.delete()
except Watchlist.DoesNotExist:
return HttpResponseNotFound()
return HttpResponse()
def make_admin(request):
body = json.loads(request.body.decode('utf-8'))
ret = {}
user = get_user(request)
try:
to_admin = User.objects.get(email=body["user"])
except User.DoesNotExist:
return HttpResponseNotFound()
if (user.is_admin):
make_user_admin(to_admin)
return HttpResponse()
return HttpResponseForbidden()
def details(request):
# TODO also give time series
# current price
try:
user = get_user(request)
portfolio = Portfolio.objects.get(email=user.email)
holdings = portfolio.get_stock_ownerships()
ret = {"stocks": []}
for h in holdings:
# TODO we should use query set sort or make use of meta
transactions = list(Transaction.objects.filter(stockOwnership=h))
transactions.sort(key=lambda x: x.purchase_date)
retTrans = [
{ #"uuid" : str(t.id),
"volume": str(t.purchase_vol),
"price": str(t.purchase_price),
"date": str(t.purchase_date)
} for t in transactions
]
#h.recalculate()
ret["stocks"].append({
"name":
str(h.get_stock_name()),
"ticker":
str(h.get_stock_ticker()),
"volume":
h.volume,
"vwap":
h.VWAP,
"price":
stock_api.get_price(h.get_stock_ticker()),
"first_purchase_date":
str(h.first_purchase),
"transactions":
retTrans
})
return HttpResponse(json.dumps(ret))
except Exception as e:
return HttpResponseBadRequest("portfolio details bad request")
return HttpResponseBadRequest("portfolio details really bad request")
def set_stock_api_priority(request):
body = json.loads(request.body.decode('utf-8'))
ret = {}
user = get_user(request)
new_stock_priorities = body["new_priorities"]
priorities = []
if is_admin(user):
for i in new_stock_priorities:
priorities.append(i['priority'])
if (len(priorities) > len(set(priorities))):
return HttpResponseBadRequest()
else:
StockApiInterface.set_stock_api_order(new_stock_priorities)
return HttpResponse()
else:
return HttpResponseForbidden()
return HttpResponseBadRequest()
def summary(request):
# TODO change %
try:
user = get_user(request)
portfolio = Portfolio.objects.get(email=user.email)
pInvestment = portfolio.get_investment()
pValue = portfolio.get_value()
pProfit = pValue - pInvestment
pValueTm1 = portfolio.get_value
pLastUpdate = str(portfolio.last_update)
ownerships = list(portfolio.get_stock_ownerships())
ownerships.sort(reverse=True, key=lambda x: x.VWAP * x.volume)
ownerships = ownerships[:min(5, len(ownerships))] # get top 5
pKeyStocks = [{
"name":
so.get_stock_name(),
"ticker":
so.get_stock_ticker(),
"value":
stock_api.get_price(so.get_stock_ticker()) * so.volume
} for so in ownerships]
ret = {
"value": pValue,
"profit": pProfit,
"last_update": pLastUpdate,
"stocks": pKeyStocks
}
return HttpResponse(json.dumps(ret))
except Exception as e:
print(e)
return HttpResponseBadRequest()
return HttpResponseBadRequest()
def get_watchlist_stocks(request):
#given a watchlist id, return json array of stocks with relevant information
wid = int(request.GET.get("id"))
user = get_user(request)
watchlist = Watchlist.objects.get(id=wid)
if watchlist.user != user:
return HttpResponseBadRequest("you naughty naughty")
tickers = [
sw.ticker
for sw in list(StockWatch.objects.filter(watchlist=watchlist))
]
stock_data_list = []
for ticker in tickers:
stock_dict = {}
stock_dict['ticker'] = ticker
stock_dict['price'] = stock_api.get_price(ticker)
stock_dict['name'] = stock_api.check_stock(ticker)['name']
stock_dict['prices'] = stock_api.get_stock_prices(ticker, "market")
stock_data_list.append(stock_dict)
return HttpResponse(json.dumps(stock_data_list))
def check_admin(request):
ret = {}
user = get_user(request)
ret["is_admin"] = is_admin(user)
return HttpResponse(json.dumps(ret))