org.py

from flask import render_template, redirect, url_for, request, flash, g
from sqlalchemy import and_, or_
from sqlalchemy.orm import aliased, joinedload
from typing import List, Set, Dict

import mo.db as db
import mo.rights
import mo.users
from mo.web import app
from mo.web.jinja import user_url
from mo.web.table import Table, Row, Column


@app.route('/org/')
def org_index():
    if 'place' in request.args:
        code = request.args['place']
        place = db.get_place_by_code(code)
        if place is not None:
            return redirect(url_for('org_place', id=place.place_id))
        else:
            flash(f'Místo s kódem {code} neexistuje', 'danger')

    if 'uid' in request.args:
        try:
            uid = int(request.args['uid'])
            user = mo.users.user_by_uid(uid)
            if user is not None:
                return redirect(user_url(user))
            flash(f'Uživatel s ID {uid} neexistuje', 'danger')
        except ValueError:
            flash('ID uživatele musí být číslo', 'danger')

    sess = db.get_session()
    ctr = (sess.query(db.Contest, db.UserRole)
               .select_from(db.UserRole, db.Round, db.Contest)
               .filter(and_(db.UserRole.user_id == g.user.user_id,
                            or_(db.UserRole.category == None, db.UserRole.category == db.Round.category),
                            or_(db.UserRole.year == None, db.UserRole.year == db.Round.year),
                            or_(db.UserRole.seq == None, db.UserRole.seq == db.Round.seq),
                            db.Round.year == mo.current_year,
                            db.Contest.round_id == db.Round.round_id,
                            db.Contest.place_id == db.UserRole.place_id))
               .options(joinedload(db.Contest.place))
               .order_by(db.Round.level, db.Round.category, db.Round.seq, db.Round.part,
                         db.Contest.place_id, db.Contest.contest_id)
               .all())

    # Pokud máme pro jednu soutěž více rolí, zkombinujeme je
    contests: List[db.Contest] = []
    contest_role_sets: Dict[db.Contest, Set[db.RoleType]] = {}
    for ct, ur in ctr:
        if len(contests) == 0 or contests[-1] != ct:
            contests.append(ct)
            contest_role_sets[ct.contest_id] = set()
        contest_role_sets[ct.contest_id].add(ur.role)

    # Role pro každou soutěž setřídíme podle důležitosti
    contest_roles: Dict[db.Contest, List[db.RoleType]] = {
        ct_id: sorted(list(contest_role_sets[ct_id]), key=lambda r: mo.rights.role_order_by_type[r])
        for ct_id in contest_role_sets.keys()
    }

    return render_template('org_index.html', contests=contests, contest_roles=contest_roles, role_type_names=db.role_type_names)


school_export_columns = (
    Column(key='code', name='kod'),
    Column(key='name', name='nazev'),
    Column(key='town_code', name='kod_obce'),
    Column(key='town', name='obec'),
    Column(key='red_izo', name='red_izo'),
    Column(key='ico', name='ico'),
    Column(key='official_name', name='ofic_nazev'),
    Column(key='address', name='adresa'),
    Column(key='is_zs', name='typ_zs'),
    Column(key='is_ss', name='typ_ss'),
)


@app.route('/org/export/skoly')
def org_export_skoly():
    sess = db.get_session()
    format = request.args.get('format', 'en_csv')

    def gen_rows():
        town = aliased(db.Place)
        for p, s, t in (
                sess.query(db.Place, db.School, town)
                .filter(db.Place.type == db.PlaceType.school)
                .filter(db.Place.place_id == db.School.place_id)
                .filter(db.Place.parent == town.place_id)
                .yield_per(100)):
            yield Row(keys={
                'code': p.get_code(),
                'name': p.name,
                'red_izo': s.red_izo,
                'ico': s.ico,
                'official_name': s.official_name,
                'address': s.address,
                'is_zs': int(s.is_zs),
                'is_ss': int(s.is_ss),
                'town_code': t.get_code(),
                'town': t.name,
            })

    table = Table(school_export_columns, gen_rows(), 'skoly')
    return table.send_as(format, streaming=True)