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()