def delete_event(id):
try:
db.query(model.Event).filter_by(id=id).delete()
commit()
except:
request_logger.exception("Failed to delete event (id=%d)" % id)
raise
return {"status": "OK"}
def events():
query = db.query(model.Event)\
.options(
selectinload(model.Event.teams_part)\
.joinedload(model.EventTeam.team, innerjoin=True),
selectinload(model.Event.judgings)\
.joinedload(model.EventJudging.judge, innerjoin=True)
)
params = flask.request.values
query = filter_events(query, params)
if "limit" in params:
query = query.limit(params.get("limit", type=int))
ret = query.all()
return [{
"id": e.id,
"block": {
"id": e.block_id,
"name": get_block(e).name
},
"ts_sched": e.ts_sched,
"arena": e.arena,
"teams": list(map(jsonify, e.teams)),
"judges": list(map(jsonify, e.judges))
} for e in ret]
def get_judging(self, judge_id, id):
return db.query(model.EventJudging)\
.filter_by(judge_id=judge_id, event_id=id)\
.options(
joinedload(model.EventJudging.event, innerjoin=True)
.joinedload(model.Event.teams_part, innerjoin=True)
.joinedload(model.EventTeam.team, innerjoin=True)
).first()
def judges():
judges = db.query(model.Judge).all()
if "with_keys" in flask.request.values:
check_admin()
return [{**jsonify(j), "key": j.key} for j in judges]
return list(map(jsonify, judges))
def get_teams(self):
query = db.query(model.Team)\
.order_by(model.Team.name)
if self.hide_shadows:
query = query.filter_by(is_shadow=False)
return query.all()
def search(self):
teams = self.get_teams()
days = db.query(
sa.func.strftime("%s", model.Event.ts_sched, "unixepoch",
"localtime", "start of day")).distinct().all()
tournament = flask.current_app.tournament
return flask.render_template("timetable/search.html",
teams=teams,
days=[int(day) for (day, ) in days],
blocks=tournament.blocks.values())
def teams():
query = db.query(model.Team)
if "include_shadows" in flask.request.values:
return [{
**jsonify(t), "shadow": bool(t.is_shadow)
} for t in query.all()]
query = query.filter_by(is_shadow=False)
return list(map(jsonify, query.all()))
def delete_judge(id):
judge = db.query(model.Judge).filter_by(id=id).first()
if judge is None:
raise ApiError("Judge doesn't exist", code=404)
db.delete(judge)
commit()
return {"status": "OK"}
def update_judge(id, json):
judge = db.query(model.Judge).filter_by(id=id).first()
if judge is None:
raise ApiError("Judge doesn't exist", code=404)
parse_judge(judge, json)
commit()
return {**jsonify(judge), "key": judge.key}
def delete_team(id):
team = db.query(model.Team).filter_by(id=id).first()
if team is None:
raise ApiError("Team doesn't exist", code=404)
db.delete(team)
commit()
return {"status": "OK"}
def update_team(id, json):
team = db.query(model.Team).filter_by(id=id).first()
if team is None:
raise ApiError("Team doesn't exist", code=404)
parse_team(team, json)
commit()
return {**jsonify(team), "shadow": bool(team.is_shadow)}
def get_last_judgings(self, limit):
return db.query(model.EventJudging)\
.filter(~model.EventJudging.is_future)\
.order_by(model.EventJudging.ts.desc())\
.limit(limit)\
.options(
joinedload(model.EventJudging.event, innerjoin=True)
.joinedload(model.Event.teams_part, innerjoin=True)
.joinedload(model.EventTeam.team, innerjoin=True)
)\
.all()
def set_user_id(self):
if user.is_admin and "as" in flask.request.values:
flask.g.judging_user = db.query(model.Judge)\
.filter_by(id=flask.request.values.get("as", type=int))\
.first() or flask.abort(400)
flask.g.judging_is_real_user = False
elif user.logged_in:
flask.g.judging_user = user
flask.g.judging_is_real_user = True
else:
raise UnauthorizedError()
def reset_judging(event_id, judge_id):
judging = db.query(model.EventJudging)\
.filter_by(event_id=event_id, judge_id=judge_id)\
.options(joinedload(model.EventJudging.scores, innerjoin=True))\
.first()
if judging is None:
raise ApiError("Judging doesn't exist", code=404)
judging.ts = None
for s in judging.scores:
s.data = None
commit()
return {"status": "OK"}
def login(self):
if flask.request.method == "POST":
try:
key = flask.request.form["key"]
except KeyError:
return flask.render_template("login/judge.html",
error="Puuttuva avain")
u = db.query(model.Judge).filter_by(key=key).first()
if u is None:
return flask.render_template("login/judge.html",
error="Tuomaria ei löytynyt")
user.login(u.id, u.name)
flask.flash("Olet nyt tuomari: %s" % u.name, "success")
return flask.redirect(flask.request.args.get("return_to", "/"))
return flask.render_template("login/judge.html")
def scores():
query = db.query(model.Event)\
.options(
joinedload(model.Event.scores, innerjoin=True)
)
query = filter_events(query, flask.request.values)
ret = query.all()
return dict((
e.id,
[
{
"team_id": s.team_id,
"judge_id": s.judge_id,
"score": {
"data": {}, # TODO json encoderit näille
"desc": str(s.score_obj)
} if s.has_score else None
} for s in e.scores
]) for e in ret)
def get_blocks(self):
tournament = flask.current_app.tournament
ret = collections.defaultdict(dict)
judging_counts = db.query(
model.Event.block_id,
sa.func.count(model.EventJudging.ts),
sa.func.count()
)\
.select_from(model.Event)\
.join(model.Event.judgings)\
.group_by(model.Event.block_id)\
.all()
for id, j, j_max in judging_counts:
ret[id].update({"j": j, "j_max": j_max})
for id, block in tournament.blocks.items():
ret[id].update({"block": block})
return ret.items()
def query_events(**kwargs):
#j_sub = db.query(model.EventJudging)\
# .filter(model.EventJudging.is_future==False)\
# .filter(model.EventJudging.event_id==model.Event.id)
#query = db.query(model.Event, ~j_sub.exists())\
# .join(model.Event.teams_part)\
# .join(model.EventTeam.team)\
# .options(
# contains_eager(model.Event.teams_part)
# .contains_eager(model.EventTeam.team)
# )
query = db.query(model.Event)\
.options(
subqueryload(model.Event.teams_part)
.joinedload(model.EventTeam.team, innerjoin=True)
)
if kwargs.get("hide_shadows"):
query = hide_query_shadows(query)
if "block_ids" in kwargs:
query = query.filter(model.Event.block_id.in_(kwargs["block_ids"]))
if "arenas" in kwargs:
query = query.filter(model.Event.arena.in_(kwargs["arenas"]))
if "team_names" in kwargs:
#query = query.filter(model.Team.name.in_(kwargs["team_names"]))
query = query.join(model.Event.teams_part)\
.join(model.EventTeam.team)\
.filter(model.Team.name.in_(kwargs["team_names"]))
if "intervals" in kwargs:
query = query.filter(sa.or_(model.Event.ts_sched.between(start, end)\
for start, end in kwargs["intervals"]))
return query.all()
def get_judging_list(self, judge_id, what):
query = db.query(model.EventJudging)\
.join(model.EventJudging.event)\
.filter(model.EventJudging.judge_id==judge_id)\
.options(
contains_eager(model.EventJudging.event)
.subqueryload(model.Event.teams_part)
.joinedload(model.EventTeam.team, innerjoin=True)
)
if self.hide_shadows:
query = hide_query_shadows(query)
if what == "future":
query = query.filter(model.EventJudging.is_future)
elif what == "past":
query = query\
.filter(~model.EventJudging.is_future)\
.options(subqueryload(model.EventJudging.scores))
ret = query.all()
#print("userid=%d judgings=%s" % (user.id, str(ret)))
return ret
def update_event(json):
try:
event_data = dict((int(eid), {
"teams": set(map(int, ev["teams"])),
"judges": set(map(int, ev["judges"])),
"arena": ev["arena"],
"ts_sched": int(ev["ts_sched"])
}) for eid, ev in json.items())
except (TypeError, ValueError):
raise ApiError("Invalid event data")
query = db.query(model.Event)\
.filter(model.Event.id.in_(event_data))\
.options(
joinedload(model.Event.teams_part),
joinedload(model.Event.judgings)
)
events = query.all()
update_part = [e for e in events if\
set(t.team_id for t in e.teams_part) != event_data[e.id]["teams"]]
# Tää täytyy tehdä kahdessa osassa koska flush() kutsu välissä
# ajaa triggerit jotka poistaa vanhat scoret
if update_part:
for e in update_part:
request_logger.info("Updating participation on event %d (%s -> %s)" %\
(e.id, set(t.team_id for t in e.teams_part), event_data[e.id]["teams"]))
for e in update_part:
for t in e.teams_part:
db.delete(t)
db.flush()
db.add_all([
model.EventTeam(event_id=e.id, team_id=tid)
for tid in event_data[e.id]["teams"] for e in update_part
])
# Tuomaroinneille vanhoja scoreja ei poisteta
# Tän silmukan jälkeen e_datassa on jäljellä vaan uudet judget
for e in events:
e_data = event_data[e.id]
for j in e.judgings:
if j.judge_id in e_data["judges"]:
e_data["judges"].remove(j.judge_id)
else:
request_logger.info("Removing judge %d from event %d" %
(j.judge_id, e.id))
db.delete(j)
for e in events:
if event_data[e.id]["judges"]:
request_logger.info("Adding judges: %s to event %d" %
(event_data[e.id]["judges"], e.id))
db.add_all([
model.EventJudging(event_id=e.id, judge_id=jid)
for jid in event_data[e.id]["judges"] for e in events
])
# Lopuks loput tiedot
for e in events:
e_data = event_data[e.id]
e.arena = e_data["arena"]
e.ts_sched = e_data["ts_sched"]
try:
commit()
except:
request_logger.exception("Failed to commit event update")
raise
# Hae uudestaan yhdellä kyselyllä, muuten sqlalchemy hakee jokaisen erikseen
return dict((e.id, jsonify_event(e)) for e in query.all())
def get_dates():
query = db.query(sa.func.min(model.Event.ts_sched),
sa.func.max(model.Event.ts_sched)).select_from(
model.Event)
min_ts, max_ts = query.first()