def NFLRoute():
session = Session(engine)
results1 = session.query(
NFL_Route.Index,
NFL_Route.Home_Team,
NFL_Route.Away_Team,
NFL_Route.Winner_Home,
NFL_Route.Odds_Home,
NFL_Route.Odds_Away).all()
session.close()
result_list1 = []
for Index, Home_Team, Away_Team, Winner_Home, Odds_Home, Odds_Away in results1:
NFL = {}
NFL["index"] = Index
NFL["Home_Team"] = Home_Team
NFL["Away_Team"] = Away_Team
NFL["Winner_Home"] = Winner_Home
NFL["Odds_Home"] = Odds_Home
NFL["Odds_Away"] = Odds_Away
result_list1.append(NFL)
return jsonify(result_list1)
def UFCRoute():
session = Session(engine)
results3 = session.query(
UFC_Route.index,
UFC_Route.Red_Corner_Fighter,
UFC_Route.Blue_Corner_Fighter,
UFC_Route.Odds_Red_Fighter,
UFC_Route.Odds_Blue_Fighter,
UFC_Route.Winner,
UFC_Route.index).all()
session.close()
result_list3 = []
for index, Red_Corner_Fighter, Blue_Corner_Fighter, Odds_Red_Fighter, Odds_Blue_Fighter, Winner, index in results3:
UFC1 = {}
UFC1["index"] = index
UFC1["Red_Corner_Fighter"] = Red_Corner_Fighter
UFC1["Blue_Corner_Fighter"] = Blue_Corner_Fighter
UFC1["Odds_Red_Fighter"] = Odds_Red_Fighter
UFC1["Odds_Blue_Fighter"] = Odds_Blue_Fighter
UFC1["Winner"] = Winner
result_list3.append(UFC1)
return jsonify(result_list3)
def defense_team(player_id=None):
next_game_id = player.Career(player_id=player_id).next_game()
session = Session(engine)
results = session.query(defense.Team, defense.abb, defense.DEF_EFF,
defense.EFG, defense.TwoP, defense.ThreeP,
defense.ThreePA, defense.REB, defense.DEFREB,
defense.AST, defense.PACE).all()
session.close()
table = []
for team, abb, def_eff, efg, two, three, threeA, reb, defReb, ast, pace in results:
if (abb == next_game_id["VS_TEAM_ABBREVIATION"][0]):
data = {}
data["aTeam"] = team
data["bDEF_EFF"] = def_eff
data["cEFG"] = efg
data["d2P"] = two
data["e3P"] = three
data["f3PA"] = threeA
data["gREB"] = reb
data["hDEF_REB"] = defReb
data["iAST"] = ast
data["jPACE"] = pace
table.append(data)
else:
pass
return jsonify(table)
def register_user(login, password, mail, name) -> User:
session = db_session.create_session()
user = User()
auth = Auth()
user.is_approved = False
user.name = name
user.role = 'user'
user.key = geherate_key()
auth.login = login
auth.password = password
auth.email = mail
user.auth.append(auth)
session.add(user)
session.flush()
application = Applications()
print(user.id)
application.user_id = user.id
application.login = login
session.add(application)
session.commit()
session.close()
return user
def get_auth_data(login: str) -> Auth:
session = db_session.create_session()
user = session.query(Auth).filter(Auth.login == login).all()
session.close()
if len(user) > 0:
return user[0]
else:
return None
def admin_get_pars(page_num: int) -> dict:
session = db_session.create_session()
query = session.query(History)
page = SqlalchemyOrmPage(query, page=page_num, items_per_page=10)
pars = sorted(page.items, key=lambda x: x.id, reverse=True)
max_page = query.count() // 10 + 1
session.close()
return {'pars': pars, 'max': max_page}
def get_history(id):
session = db_session.create_session()
history = session.query(History).filter(History.id == id)
session.close()
if history:
return history[0]
else:
return None
def delete_user(id):
session = db_session.create_session()
user = session.query(User).get(id)
auth = user.auth[0]
session.delete(user)
session.delete(auth)
session.commit()
session.close()
def hw_login(request):
session = SessionLocal()
senha = request["senha"]
hash_obj = hashlib.md5(f"{senha}".encode())
md5_value = hash_obj.hexdigest()
user = (session.query(Cadastro).filter_by(email=request["email"],
senha=md5_value).first())
login_user(user)
session.close()
return "Voce entrou"
def eloroute():
session = Session(engine)
data = session.query(Team.nickname, Elo.elo).filter(Team.team_id == Elo.team_id).all()
session.close()
elos = []
for x, y in data:
team = {}
team["nickname"] = x
team["elo"] = y
elos.append(team)
return jsonify(elos)
def admin_decline_user(id):
if check_user(id):
session = db_session.create_session()
user = session.query(User).get(id)
session.delete(user)
session.delete(
session.query(Applications).filter(
Applications.user_id == id).first())
session.commit()
session.close()
return True
def admin_accept_user(id):
if check_user(id):
session = db_session.create_session()
user = session.query(User).get(id)
user.is_approved = True
application = session.query(Applications).filter(
Applications.user_id == id).first()
session.delete(application)
session.commit()
session.close()
return True
def admin_get_users(page_num: int) -> dict:
session = db_session.create_session()
query = session.query(User).filter(User.is_approved == True)
page = SqlalchemyOrmPage(query, page=page_num, items_per_page=10)
users = sorted(page.items, key=lambda x: x.id, reverse=True)
max_page = query.count() // 10 + 1
for user in users:
auth = user.auth
user.auth = auth
session.close()
return {'users': users, 'max': max_page}
def playersroute():
session = Session(engine)
results = session.query(players_team.player_id, players_team.team_id, players_team.player_name).all()
session.close()
players_team_list = []
for player_id, team_id, name in results:
player = {}
player["player_id"] = player_id
player["team_id"] = team_id
player["player_name"] = name
players_team_list.append(player)
return jsonify(players_team_list)
def admin_get_reg(page_num: int) -> dict:
session = db_session.create_session()
query = session.query(Applications)
page = SqlalchemyOrmPage(query, page=page_num, items_per_page=10)
users = sorted(page.items, key=lambda x: x.date)
for application in users:
user = application.user
auth = user.auth
user.auth = auth
application.user = user
max_page = query.count() // 10 + 1
session.close()
return {'users': users, 'max': max_page}
def playersroute():
session = Session(engine)
results = session.query(players.PERSON_ID, players.TEAM_ID,
players.DISPLAY_FIRST_LAST).all()
session.close()
players_team_list = []
for player_id, team_id, name in results:
player = {}
player["player_id"] = player_id
player["team_id"] = team_id
player["player_name"] = name
players_team_list.append(player)
return jsonify(players_team_list)
def teamsroute():
session = Session(engine)
results = session.query(teams.team_id, teams.abbreviation, teams.nickname, teams.city).all()
session.close()
team_list = []
for team_id, abr, nickname, city in results:
team = {}
team["id"] = team_id
team["abr"] = abr
team["nickname"] = nickname
team["city"] = city
team_list.append(team)
return jsonify(team_list)
def hw_add_cadastro(request):
session = SessionLocal()
senha = request["senha"]
hash_obj = hashlib.md5(f"{senha}".encode())
md5_value = hash_obj.hexdigest()
cadastro = Cadastro(nome=request["nome"],
email=request["email"],
senha=md5_value)
cadastro_json = populate_cadastro([cadastro])
session.add(cadastro)
session.commit()
session.close()
return cadastro_json
def register_admin(login, password, mail, name) -> User:
session = db_session.create_session()
user = User()
auth = Auth()
user.is_approved = True
user.name = name
user.role = 'admin'
user.key = geherate_key()
auth.login = login
auth.password = password
auth.email = mail
user.auth.append(auth)
session.add(user)
session.commit()
session.close()
def elochartroute():
session = Session(engine)
sel = [Elos.newdatex, Elos.bucks, Elos.raptors, Elos.sixers,
Elos.celtics, Elos.pacers, Elos.nets, Elos.magic, Elos.pistons, Elos.hornets,
Elos.heat, Elos.wizards, Elos.hawks, Elos.bulls, Elos.cavs,
Elos.knicks, Elos.warriors, Elos.nuggets, Elos.rockets, Elos.blazers, Elos.jazz, Elos.thunder, Elos.clippers,
Elos.spurs, Elos.kings, Elos.lakers, Elos.timberwolves, Elos.mavericks, Elos.grizzlies, Elos.pelicans, Elos.suns]
results = session.query(*sel).order_by(Elos.newdate).all()
session.close()
elo_list = []
for result in results:
elo_dict ={}
elo_dict["Date"] = result[0]
elo_dict["Milwaukee Bucks"] = result[1]
elo_dict["Toronto Raptors"] = result[2]
elo_dict["Philadelphia 76ers"] = result[3]
elo_dict["Boston Celtics"] = result[4]
elo_dict["Indiana Pacers"] = result[5]
elo_dict["Brooklyn Nets"] = result[6]
elo_dict["Orlando Magic"] = result[7]
elo_dict["Detroit Pistons"] = result[8]
elo_dict["Charlotte Hornets"] = result[9]
elo_dict["Miami Heat"] = result[10]
elo_dict["Washington Wizards"] = result[11]
elo_dict["Atlanta Hawks"] = result[12]
elo_dict["Chicago Bulls"] = result[13]
elo_dict["Cleveland Cavaliers"] = result[14]
elo_dict["New York Knicks"] = result[15]
elo_dict["Golden State Warriors"] = result[16]
elo_dict["Denver Nuggets"] = result[17]
elo_dict["Houston Rockets"] = result[18]
elo_dict["Portland Trail Blazers"] = result[19]
elo_dict["Utah Jazz"] = result[20]
elo_dict["Oklahoma City Thunder"] = result[21]
elo_dict["Los Angeles Clippers"] = result[22]
elo_dict["San Antonio Spurs"] = result[23]
elo_dict["Sacramento Kings"] = result[24]
elo_dict["Los Angeles Lakers"] = result[25]
elo_dict["Minnesota Timberwolves"] = result[26]
elo_dict["Dallas Mavericks"] = result[27]
elo_dict["Memphis Grizzlies"] = result[28]
elo_dict["New Orleans Pelicans"] = result[29]
elo_dict["Phoenix Suns"] = result[30]
elo_list.append(elo_dict)
# print(f'printing date {elo_list[1]["Date"]}')
return jsonify(elo_list)
def bubbleroute():
session = Session(engine)
sel = [stats.player_id, stats.player_name, salaries.salary, stats.pos,
stats.TwoP_m, stats.ThreeP_m, stats.mp, stats.fg, stats.fga, stats.fg_percent,
stats.ThreeP_a, stats.ThreeP_percent, stats.TwoP_a, stats.TwoP_percent, stats.efg_percent,
stats.ft, stats.fta, stats.ft_percent, stats.pts, stats.orb, stats.drb, stats.trb, stats.ast,
stats.stl, stats.blk, stats.tov]
results = session.query(*sel).filter(salaries.player_id == stats.player_id).all()
session.close()
all_stats = []
for result in results:
stats_dict ={}
stats_dict["Player_id"] = result[0]
stats_dict["Player_name"] = result[1]
stats_dict["Salary"] = result[2]
stats_dict["Position"] = result[3]
stats_dict["2PT Made"] = result[4]
stats_dict["3PT Made"] = result[5]
stats_dict["Minutes Played"] = result[6]
stats_dict["Field-Goal Made"] = result[7]
stats_dict["Field-Goal Attempts"] = result[8]
stats_dict["Field-Goal %"] = result[9]
stats_dict["3PT Attempts"] = result[10]
stats_dict["3PT %"] = result[11]
stats_dict["2PT Attempts"] = result[12]
stats_dict["2PT %"] = result[13]
stats_dict["Effective Field-Goal %"] = result[14]
stats_dict["FT Made"] = result[15]
stats_dict["FT Attemps"] = result[16]
stats_dict["FT %"] = result[17]
stats_dict["Points"] = result[18]
stats_dict["Offensive Rebounds"] = result[19]
stats_dict["Defensive Rebounds"] = result[20]
stats_dict["Total Rebounds"] = result[21]
stats_dict["Assists"] = result[22]
stats_dict["Steals"] = result[23]
stats_dict["Blocks"] = result[24]
stats_dict["Turnovers"] = result[25]
all_stats.append(stats_dict)
return jsonify(all_stats)
def modelroute():
session = Session(engine)
data = session.query(Model.game_id, Model.home, Model.away, Model.home_win, Model.away_win, Model.projected_winner, Model.predicted_line, Model.elo_home, Model.elo_away).all()
session.close()
model = []
for game_id, home, away, home_win, away_win, proj_win, line, ELO_h, ELO_a in data:
game = {}
game["id"] = game_id
game["home"] = home
game["away"] = away
game["home_win"] = home_win
game["away_win"] = away_win
game["proj_win"] = proj_win
game["line"] = line
game["elo_h"] = ELO_h
game["elo_a"] = ELO_a
model.append(game)
return jsonify(model)
def HorseRoute():
session = Session(engine)
results2 = session.query(
Horse_Route.Track,
Horse_Route.Horse,
Horse_Route.BetType,
Horse_Route.Odds,
Horse_Route.Winner).all()
session.close()
result_list2 = []
for Track, Horse, BetType, Odds, Winner in results2:
Horseracing = {}
Horseracing["Track"] = Track
Horseracing["Horse"] = Horse
Horseracing["BetType"] = BetType
Horseracing["Odds"] = Odds
Horseracing["Winner"] = Winner
result_list2.append(Horseracing)
return jsonify(result_list2)
def check_login(login: str) -> bool:
session = db_session.create_session()
data = bool(session.query(Auth).filter(Auth.login == login).count())
session.close()
return data
def check_mail(mail: str) -> bool:
session = db_session.create_session()
data = bool(session.query(Auth).filter(Auth.email == mail).count())
session.close()
return data
def teamsroute():
session = Session(engine)
session.close()
team_list = []
return jsonify(team_list)
def futureroute():
session = Session(engine)
session.close()
future_df = {}
return jsonify(future_df)
def get_user(id) -> User:
session = db_session.create_session()
data = session.query(User).get(id)
session.close()
return data
def hw_get_cadastros():
session = SessionLocal()
cadastros = session.query(Cadastro).order_by(Cadastro.nome.asc()).all()
cadastros_json = populate_cadastro(cadastros)
session.close()
return cadastros_json
def main():
session = Session(engine)
data = session.query(combine.player_id, stats.player_name, stats.pos).filter(combine.player_id == stats.player_id).all()
session.close()
return jsonify(data)
