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 getPerformance(training: Training,
track: Track = None,
category: Category = None):
session = getSession()
if not track:
track = session.query(Track).get(training.track_id)
if not category:
category = session.query(Category).get(training.category_id)
size = int(track.size) / 1000
turns = (7 / (size * 60)) / (1 / (3 * category.duration_max))
return (training.turns * 100) / turns
def auth_check(user_id, user_name):
session = Session()
user = session.query(User).filter_by(user_name=user_name).one()
if int(user_id) != user.id:
abort(403, description="Access forbiden")
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 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 temp_monthly():
prev_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)
results = session.query(Measurement.tobs).\
filter(Measurement.station == 'USC00519281').\
filter(Measurement.date >= prev_year).all()
temps = list(np.ravel(results))
return jsonify(temps=temps)
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 getPerformanceCompetence(competence: Competence,
track: Track = None,
category: Category = None,
userCompetence: UserCompetence = None):
session = getSession()
if not track:
track = session.query(Track).get(competence.track_id)
if not category:
category = session.query(Category).get(competence.category_id)
if not userCompetence:
userCompetence = session.query(UserCompetence).filter(
UserCompetence.competences_id == competence.id,
UserCompetence.user_id == current_user.id).first()
size = int(track.size) / 1000
turns = (7 / (size * 60)) / (1 / (3 * category.duration_max))
return (int((userCompetence.turns * 100) / turns))
def update_reservation(reservation_id):
session = Session()
try:
reservation = session.query(Reservation).filter_by(
id=int(reservation_id)).one()
except:
abort(404, description="Reservation not found")
auth_check(reservation.user_id, auth.current_user())
data = request.get_json()
try:
if data.get('from_date', None):
d = datetime.strptime(data['from_date'], '%Y-%m-%d')
reservation.from_date = d.date()
if data.get('to_date', None):
d = datetime.strptime(data['to_date'], '%Y-%m-%d')
reservation.to_date = d.date()
if data.get('audience_id', None):
reservation.audience_id = data['audience_id']
except Exception:
return jsonify({"Message": "Invalid input"}), 405
compare_dates(reservation.from_date, reservation.to_date)
try:
audience = session.query(Audience).filter_by(
id=int(reservation.audience_id)).one()
except:
abort(404, description="Audience not found")
reservations = session.query(Reservation).filter_by(
audience_id=int(audience.id)).all()
for reserv_other in reservations:
if reserv_other.id != reservation.id:
check_dates(reservation.from_date, reserv_other.from_date,
reserv_other.to_date)
check_dates(reservation.to_date, reserv_other.from_date,
reserv_other.to_date)
session.commit()
return jsonify({"Success": "Reservation has been changed"}), 200
def get_audience(audience_id):
session = Session()
try:
audience = session.query(Audience).filter_by(id=int(audience_id)).one()
except:
abort(404, description="Audience not found")
return AudienceSchema().dump(audience)
def delete_user(user_id):
session = Session()
auth_check(user_id, auth.current_user())
user = session.query(User).filter_by(id=int(user_id)).one()
reservations = session.query(Reservation).filter_by(
user_id=int(user_id)).all()
session.delete(user)
for reservation in reservations:
session.delete(reservation)
session.commit()
return jsonify({"Success": "User has been deleted"}), 200
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 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 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_reservation():
session = Session()
reservations = session.query(Reservation).all()
result = ReservationSchema(many=True).dump(reservations)
return jsonify(result)
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 verify_password(username, password):
session = Session()
try:
user = session.query(User).filter_by(user_name=username).one()
except:
abort(404, description="User not found")
return bcrypt.check_password_hash(user.password, password)
def stats(start=None, end=None):
sel = [
func.min(Measurement.tobs),
func.avg(Measurement.tobs),
func.max(Measurement.tobs)
]
if not end:
results = session.query(*sel).\
filter(Measurement.date >= start).all()
temps = list(np.ravel(results))
return jsonify(temps)
results = session.query(*sel).\
filter(Measurement.date >= start).\
filter(Measurement.date <= end).all()
temps = list(np.ravel(results))
return jsonify(temps)
def get_category():
session = current_app.db.session
categories_list = [{
'id': category.id,
'name': category.name
} for category in session.query(CategoryModel).all()]
return jsonify(categories_list), HTTPStatus.OK
def get_all_audience():
session = Session()
all_audience = session.query(Audience).all()
if len(all_audience) == 0:
abort(404, description="Audiences not found")
result = audience_schema.dump(all_audience)
return jsonify(result)
def get():
query = session.query(
Product.id_prodocut,
Product.name_product,
Type.id_type,
Type.name_type,
)
join_query = query.join(Product).join(Type)
return join_query.filter(Product.id_type == Type.id_type).all()
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 get_user(user_id):
session = Session()
print(auth.current_user())
auth_check(user_id, auth.current_user())
user = session.query(User).filter_by(id=int(user_id)).one()
return UserSchema().dump(user)
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 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 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 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 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}
