bin/create-user

@@ -4,6 +4,7 @@ import argparse
 import sys
 
 import mo.db as db
+import mo.email
 import mo.users
 import mo.util
 
@@ -13,8 +14,7 @@ parser.add_argument(dest='first_name', help='křestní jméno (jedno nebo více)
 parser.add_argument(dest='last_name', help='příjmení (jedno nebo více)')
 parser.add_argument('--org', default=False, action='store_true', help='přidělí uživateli organizátorská práva')
 parser.add_argument('--admin', default=False, action='store_true', help='přidělí uživateli správcovská práva')
-parser.add_argument('--passwd', type=str, help='nastaví počáteční heslo')
-parser.add_argument('--mail', default=False, action='store_true', help='pošle uživateli mail o založení účtu')
+parser.add_argument('--passwd', type=str, help='nastaví počáteční heslo (jinak pošle aktivační mail)')
 
 args = parser.parse_args()
 email = mo.users.normalize_email(args.email)
@@ -45,11 +45,9 @@ mo.util.log(db.LogType.user, user.user_id, {
 
 if args.passwd is not None:
     mo.users.set_password(user, args.passwd)
-
-if args.mail:
-    token = mo.users.ask_reset_password(user)
+    token = mo.users.make_activation_token(user)
 
 session.commit()
 
-if args.mail:
-    mo.util.send_new_account_email(user, token)
+if args.passwd is None:
+    mo.email.send_new_account_email(user, token)

bin/reset-user

 #!/usr/bin/env python3
 
 import argparse
-import sys
 
-import mo.config as config
+import mo.config
+import mo.email
 import mo.db as db
 import mo.users
 import mo.util
 
-parser = argparse.ArgumentParser(description='Resetuje uživateli heslo a pošle mail')
+parser = argparse.ArgumentParser(description='Pošle uživateli nový aktivační mail')
 parser.add_argument(dest='email', help='e-mailová adresa')
-parser.add_argument('--new', default=False, action='store_true', help='pošle mail o založení účtu')
 parser.add_argument('--mail-instead', metavar='EMAIL', default=None, help='pošle mail někomu jinému')
 
 args = parser.parse_args()
@@ -22,13 +21,10 @@ user = mo.users.user_by_email(args.email)
 if user is None:
     mo.util.die('Tento uživatel neexistuje')
 
-token = mo.users.ask_reset_password(user)
+token = mo.users.make_activation_token(user)
 session.commit()
 
 if args.mail_instead:
     mo.config.MAIL_INSTEAD = args.mail_instead
 
-if args.new:
-    mo.util.send_new_account_email(user, token)
-else:
-    mo.util.send_password_reset_email(user, token)
+mo.email.send_new_account_email(user, token)

db/db.ddl

 -- CREATE ROLE mo_osmo LOGIN PASSWORD 'pass';
 -- CREATE DATABASE mo_osmo WITH OWNER=mo_osmo;
 -- GRANT mo_osmo TO some_admin;
+-- CREATE EXTENSION unaccent;
 
 SET ROLE mo_osmo;
 
+-- Funkce pro odakcentování textu pomocí extension unaccent.
+-- Je immutable, takže se dá používat i v indexech.
+-- Zdroj: http://stackoverflow.com/questions/11005036/does-postgresql-support-accent-insensitive-collations
+CREATE OR REPLACE FUNCTION f_unaccent(text)
+  RETURNS text AS
+$func$
+SELECT unaccent('unaccent', $1)
+$func$  LANGUAGE sql IMMUTABLE SET search_path = public, pg_temp;
+
 -- Uživatelský účet
 CREATE TABLE users (
 	user_id		serial		PRIMARY KEY,
@@ -15,7 +25,7 @@ CREATE TABLE users (
 	is_test		boolean		NOT NULL DEFAULT false,		-- testovací účastník, není vidět ve výsledkovkách
 	created_at	timestamp with time zone	NOT NULL DEFAULT CURRENT_TIMESTAMP,
 	last_login_at	timestamp with time zone	DEFAULT NULL,
-	reset_at	timestamp with time zone	DEFAULT NULL,	-- poslední požadavek na reset hesla
+	reset_at	timestamp with time zone	DEFAULT NULL,	-- poslední reset/aktivace nebo žádost o ně
 	password_hash	varchar(255)	DEFAULT NULL,			-- heš hesla (je-li nastaveno)
 	note		text		NOT NULL DEFAULT ''		-- poznámka viditelná pro orgy
 );
@@ -45,6 +55,8 @@ CREATE TABLE places (
 );
 
 CREATE INDEX places_parent_index ON places (parent);
+-- XXX: Potřebujeme operator class text_pattern_ops, aby index fungoval na prefixové LIKE
+CREATE INDEX places_noacc_index ON places ((lower(f_unaccent(name))) text_pattern_ops);
 
 -- Rekurzivní dotaz na nadřazené regiony:
 --	WITH RECURSIVE parent_regions(parent, place_id) AS (
@@ -89,6 +101,12 @@ CREATE TYPE score_mode AS ENUM (
 	'mo'				-- jednoznačné pořadí podle pravidel MO
 );
 
+CREATE TYPE enroll_mode AS ENUM (	-- režim přihlašování účastníků
+	'manual',			-- přihlašuje organizátor
+	'register',			-- účastník se registruje
+	'confirm'			-- účastník se registruje, ale org ho musí potvrdit
+);
+
 CREATE TABLE rounds (
 	round_id	serial		PRIMARY KEY,
 	master_round_id	int		DEFAULT NULL REFERENCES rounds(round_id),
@@ -109,6 +127,8 @@ CREATE TABLE rounds (
 	score_successful_limit	int	DEFAULT NULL,			-- bodový limit na označení za úspěšného řešitele
 	points_step	numeric(2,1)	NOT NULL DEFAULT 1,		-- s jakou přesností jsou přidělovány body (celé aneb 1, 0.5, 0.1)
 	has_messages	boolean		NOT NULL DEFAULT false,		-- má zprávičky
+	enroll_mode	enroll_mode	NOT NULL DEFAULT 'manual',	-- režim přihlašování (pro vyšší kola vždy 'manual')
+	enroll_advert	varchar(255)	NOT NULL DEFAULT '',		-- popis v přihlašovacím formuláři
 	UNIQUE (year, category, seq, part)
 );
 
@@ -133,17 +153,19 @@ CREATE TABLE participants (
 	school		int		NOT NULL REFERENCES places(place_id),
 	birth_year	int		NOT NULL,
 	grade		varchar(20)	NOT NULL,			-- třída ve tvaru "X/Y"
+	registered_on	timestamp with time zone	DEFAULT NULL,	-- kdy se účastník přihlásil (NULL, pokud ho přihlásil organizátor)
 	PRIMARY KEY (user_id, year)
 );
 
 -- Účast v soutěžním kole
 
 CREATE TYPE part_state AS ENUM (
-	'registered',		-- sám se přihlásil
-	'invited',		-- pozván
-	'refused',		-- odmítl účast
-	'present',		-- soutěžil
-	'absent',		-- bez omluvy nedorazil
+	'registered',		-- sám se přihlásil, čeká na potvrzení organizátorem
+	-- 'invited',		-- pozván (už nepoužíváme)
+	'active',		-- soutěží (přihlášku zadal/potvrdil organizátor)
+	'refused',		-- organizátor odmítl přihlášku
+	-- 'present',		-- soutěžil (už nepoužíváme)
+	'absent',		-- nedorazil
 	'disqualified'		-- diskvalifikovaný
 );
 
@@ -312,3 +334,63 @@ CREATE TABLE messages (
 	markdown	text		NOT NULL,
 	html		text		NOT NULL
 );
+
+-- Požadavky na registraci a změny vlastností účtu
+
+CREATE TYPE reg_req_type AS ENUM (
+	'register',
+	'change_email',
+	'reset_password'
+);
+
+CREATE TABLE reg_requests (
+	reg_id		serial		PRIMARY KEY,
+	type		reg_req_type	NOT NULL,
+	created_at	timestamp with time zone NOT NULL,
+	expires_at	timestamp with time zone NOT NULL,
+	used_at		timestamp with time zone DEFAULT NULL,
+	email		varchar(255)	DEFAULT NULL,			-- adresa, kterou potvrzujeme
+	captcha_token	varchar(255)	DEFAULT NULL,			-- token pro fázi 1 registrace
+	email_token	varchar(255)	UNIQUE NOT NULL,		-- token pro fázi 2 registrace
+	user_id		int		DEFAULT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+	client		varchar(255)	NOT NULL			-- kdo si registraci vyžádal
+);
+
+-- Statistiky
+
+-- Pro každý region spočítáme všechna podřízená místa
+CREATE VIEW region_descendants AS
+	WITH RECURSIVE descendant_regions(place_id, descendant) AS (
+		SELECT place_id, place_id FROM places
+		UNION SELECT r.place_id, p.place_id
+		      FROM descendant_regions r, places p
+		      WHERE p.parent = r.descendant
+	) SELECT place_id AS region, descendant FROM descendant_regions;
+
+-- Pro každou trojici (kolo, region, stav soutěže) spočítáme soutěže.
+CREATE VIEW region_contest_stats AS
+	SELECT c.round_id, rd.region, c.state, count(*) AS count
+	FROM contests c
+	JOIN region_descendants rd ON rd.descendant = c.place_id
+	WHERE rd.region <> c.place_id
+	GROUP BY c.round_id, rd.region, c.state;
+
+-- Pro každou trojici (kolo, region, stav účasti) spočítáme účastníky.
+-- Pokud se to ukáže být příliš pomalé, přejdeme na materializovaná views.
+CREATE VIEW region_participant_stats AS
+	SELECT c.round_id, rd.region, p.state, count(*) AS count
+	FROM participations p
+	JOIN contests c USING(contest_id)
+	JOIN region_descendants rd ON rd.descendant = c.place_id
+	GROUP BY c.round_id, rd.region, p.state;
+
+-- Pro každou trojici (kolo, region, úloha) spočítáme řešení.
+CREATE VIEW region_task_stats AS
+	SELECT r.round_id, rd.region, t.task_id, count(*) AS count
+	FROM rounds r
+	JOIN contests c USING(round_id)
+	JOIN participations p USING(contest_id)
+	JOIN tasks t USING(round_id)
+	JOIN solutions s USING(user_id, task_id)
+	JOIN region_descendants rd ON rd.descendant = c.place_id
+	GROUP BY r.round_id, rd.region, t.task_id;

db/upgrade-20210712.sql

+SET ROLE 'mo_osmo';
+
+CREATE TYPE enroll_mode AS ENUM (	-- režim přihlašování účastníků
+	'manual',			-- přihlašuje organizátor
+	'register',			-- účastník se registruje
+	'confirm'			-- účastník se registruje, ale org ho musí potvrdit
+);
+
+ALTER TABLE rounds ADD COLUMN enroll_mode enroll_mode NOT NULL DEFAULT 'manual';
+ALTER TABLE rounds ADD COLUMN enroll_advert varchar(255) NOT NULL DEFAULT '';
+
+ALTER TYPE part_state ADD VALUE 'active' AFTER 'invited';
+
+ALTER TABLE participants ADD COLUMN registered_on timestamp with time zone DEFAULT NULL;
+
+UPDATE participations SET state='active' WHERE state IN ('registered', 'invited');
+
+CREATE TYPE reg_req_type AS ENUM (
+	'register',
+	'change_email',
+	'reset_passwd'
+);
+
+CREATE TABLE reg_requests (
+	reg_id		serial		PRIMARY KEY,
+	type		reg_req_type	NOT NULL,
+	created_at	timestamp with time zone NOT NULL,
+	expires_at	timestamp with time zone NOT NULL,
+	used_at		timestamp with time zone DEFAULT NULL,
+	email		varchar(255)	DEFAULT NULL,
+	captcha_token	varchar(255)	DEFAULT NULL,
+	email_token	varchar(255)	UNIQUE NOT NULL,
+	user_id		int		DEFAULT NULL REFERENCES users(user_id) ON DELETE CASCADE,
+	client		varchar(255)	NOT NULL
+);

db/upgrade-20210819.sql

+SET ROLE 'mo_osmo';
+
+-- Musí udělat správce (ale uvnitř naší DB):
+-- CREATE EXTENSION unaccent;
+
+CREATE OR REPLACE FUNCTION f_unaccent(text)
+  RETURNS text AS
+$func$
+SELECT unaccent('unaccent', $1)
+$func$  LANGUAGE sql IMMUTABLE SET search_path = public, pg_temp;
+
+CREATE INDEX places_noacc_index ON places ((lower(f_unaccent(name))) text_pattern_ops);

db/upgrade-20210924.sql

+SET ROLE 'mo_osmo';
+
+-- Pro každý region spočítáme všechna podřízená místa
+CREATE VIEW region_descendants AS
+	WITH RECURSIVE descendant_regions(place_id, descendant) AS (
+		SELECT place_id, place_id FROM places
+		UNION SELECT r.place_id, p.place_id
+		      FROM descendant_regions r, places p
+		      WHERE p.parent = r.descendant
+	) SELECT place_id AS region, descendant FROM descendant_regions;
+
+-- Pro každou trojici (kolo, region, stav soutěže) spočítáme soutěže.
+CREATE VIEW region_contest_stats AS
+	SELECT c.round_id, rd.region, c.state, count(*) AS count
+	FROM contests c
+	JOIN region_descendants rd ON rd.descendant = c.place_id
+	WHERE rd.region <> c.place_id
+	GROUP BY c.round_id, rd.region, c.state;
+
+-- Pro každou trojici (kolo, region, stav účasti) spočítáme účastníky.
+-- Pokud se to ukáže být příliš pomalé, přejdeme na materializovaná views.
+CREATE VIEW region_participant_stats AS
+	SELECT c.round_id, rd.region, p.state, count(*) AS count
+	FROM participations p
+	JOIN contests c USING(contest_id)
+	JOIN region_descendants rd ON rd.descendant = c.place_id
+	GROUP BY c.round_id, rd.region, p.state;
+
+-- Pro každou trojici (kolo, region, úloha) spočítáme řešení.
+CREATE VIEW region_task_stats AS
+	SELECT r.round_id, rd.region, t.task_id, count(*) AS count
+	FROM rounds r
+	JOIN contests c USING(round_id)
+	JOIN participations p USING(contest_id)
+	JOIN tasks t USING(round_id)
+	JOIN solutions s USING(user_id, task_id)
+	JOIN region_descendants rd ON rd.descendant = c.place_id
+	GROUP BY r.round_id, rd.region, t.task_id;

etc/config.py.example

@@ -42,12 +42,17 @@ MAX_BATCH_CONTENT_LENGTH = 1000000000
 # Adresář, do kterého ukládáme data (pro vývoj relativní, pro instalaci absolutní)
 DATA_DIR = 'data'
 
-# Jak často se má provádět periodická kontrola dávek [s]
-JOB_GC_PERIOD = 60
+# Jak často se má spouštět garbage collector na dávky a tokeny [s]
+GC_PERIOD = 60
 
 # Za jak dlouho expiruje dokončená dávka [min]
 JOB_EXPIRATION = 5
 
-# Automatické přihlašování účastníků do testovací soutěže
-# (kolo aktuální_ročník-T-1, celostátní soutěž)
-AUTO_REGISTER_TEST = False
+# Kolik nejvýše dovolujeme registrací za minutu
+REG_MAX_PER_MINUTE = 10
+
+# Jak dlouho vydrží tokeny používané při registraci a změnách e-mailu [min]
+REG_TOKEN_VALIDITY = 10
+
+# Aktuální ročník MO
+CURRENT_YEAR = 71

mo/__init__.py

@@ -2,9 +2,6 @@
 
 import datetime
 
-# Aktuální ročník
-current_year = 70
-
 # Referenční čas nastavovaný v initu requestu (web) nebo při volání skriptu
 now: datetime.datetime
 

mo/db.py

@@ -11,17 +11,19 @@ from sqlalchemy import \
     text, func, \
     create_engine, inspect, select
 from sqlalchemy.engine import Engine
-from sqlalchemy.orm import relationship, sessionmaker, Session, class_mapper, joinedload
+from sqlalchemy.orm import relationship, sessionmaker, Session, class_mapper, joinedload, aliased
 from sqlalchemy.orm.attributes import get_history
+from sqlalchemy.orm.query import Query
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.sql.expression import CTE
+from sqlalchemy.sql.functions import ReturnTypeFromArgs
 from sqlalchemy.sql.sqltypes import Numeric
 from typing import Optional, List, Tuple
 
 import mo
 from mo.place_level import place_levels, PlaceLevel
-from mo.util_format import timedelta, time_and_timedelta
+from mo.util_format import timeformat_short, timedelta, time_and_timedelta
 
 # HACK: Work-around for https://github.com/dropbox/sqlalchemy-stubs/issues/114
 from typing import TYPE_CHECKING, TypeVar, Type, Any
@@ -34,6 +36,11 @@ else:
     from sqlalchemy import Enum
 
 
+# Funkce f_unaccent je definovaná v db.ddl, naučme Alchymii volat ji:
+class f_unaccent(ReturnTypeFromArgs):
+    pass
+
+
 Base = declarative_base()
 metadata = Base.metadata
 
@@ -99,6 +106,7 @@ class Place(Base):
     nuts = Column(String(255), unique=True, server_default=text("NULL::character varying"))
     note = Column(Text, nullable=False, server_default=text("''::text"))
 
+    parent_place = relationship('Place', primaryjoin='Place.parent == Place.place_id', remote_side='Place.place_id')
     children = relationship('Place')
     school = relationship('School', uselist=False, back_populates='place')
 
@@ -132,6 +140,13 @@ def get_root_place():
     return get_session().query(Place).filter_by(parent=None).one()
 
 
+def get_place_by_id(place_id: int, fetch_school: bool = False) -> Place:
+    q = get_session().query(Place)
+    if fetch_school:
+        q = q.options(joinedload(Place.school))
+    return q.filter_by(place_id=place_id).one()
+
+
 def get_place_by_code(code: str, fetch_school: bool = False) -> Optional[Place]:
     code = code.strip()
     if code == "":
@@ -196,6 +211,22 @@ round_score_mode_names = {
 }
 
 
+class RoundEnrollMode(MOEnum):
+    manual = auto()
+    register = auto()
+    confirm = auto()
+
+    def friendly_name(self) -> str:
+        return round_enroll_mode_names[self]
+
+
+round_enroll_mode_names = {
+    RoundEnrollMode.manual: "Jen organizátoři",
+    RoundEnrollMode.register: "Účastníci sami",
+    RoundEnrollMode.confirm: "Potvrzení organizátorem",
+}
+
+
 # V DB jako numeric(2,1), používá se tak snadněji, než enum
 round_points_step_names = {
     decimal.Decimal('1'): "Celé body",
@@ -230,6 +261,8 @@ class Round(Base):
     score_successful_limit = Column(Numeric)
     points_step = Column(Numeric, nullable=False)
     has_messages = Column(Boolean, nullable=False, server_default=text("false"))
+    enroll_mode = Column(Enum(RoundEnrollMode, name='enroll_mode'), nullable=False, server_default=text("'basic'::enroll_mode"))
+    enroll_advert = Column(String(255), nullable=False, server_default=text("''::text"))
 
     master = relationship('Round', primaryjoin='Round.master_round_id == Round.round_id', remote_side='Round.round_id', post_update=True)
 
@@ -274,6 +307,14 @@ class Round(Base):
             return round_points_step_names[self.points_step]
         return str(self.points_step)
 
+    def format_times(self) -> str:
+        times = []
+        if self.ct_tasks_start is not None:
+            times.append('od ' + timeformat_short(self.ct_tasks_start))
+        if self.ct_submit_end is not None:
+            times.append('do ' + timeformat_short(self.ct_submit_end))
+        return " ".join(times)
+
 
 class User(Base):
     __tablename__ = 'users'
@@ -396,6 +437,7 @@ class Participant(Base):
     school = Column(Integer, ForeignKey('places.place_id'), nullable=False)
     birth_year = Column(Integer, nullable=False)
     grade = Column(String(20), nullable=False)
+    registered_on = Column(DateTime(True))
 
     user = relationship('User')
     school_place = relationship('Place', primaryjoin='Participant.school == Place.place_id')
@@ -403,9 +445,8 @@ class Participant(Base):
 
 class PartState(MOEnum):
     registered = auto()
-    invited = auto()
+    active = auto()
     refused = auto()
-    present = auto()
     absent = auto()
     disqualified = auto()
 
@@ -415,9 +456,8 @@ class PartState(MOEnum):
 
 part_state_names = {
     PartState.registered: 'přihlášený',
-    PartState.invited: 'pozvaný',
+    PartState.active: 'soutěží',
     PartState.refused: 'odmítnutý',
-    PartState.present: 'přítomný',
     PartState.absent: 'nepřítomný',
     PartState.disqualified: 'diskvalifikovaný',
 }
@@ -503,6 +543,12 @@ class UserRole(Base):
 
         return " ".join(parts)
 
+    def applies_to(self, at: Optional[Place] = None, year: Optional[int] = None, cat: Optional[str] = None, seq: Optional[int] = None) -> bool:
+        return ((at is None or self.place_id == at.place_id)
+                and (self.year is None or year is None or self.year == year)
+                and (self.category is None or cat is None or self.category == cat or (self.category == 'Z' and cat.startswith('Z')))
+                and (self.seq is None or seq is None or self.seq == seq))
+
 
 class PaperType(MOEnum):
     solution = auto()
@@ -637,6 +683,73 @@ class Message(Base):
     created_by_user = relationship('User')
 
 
+class RegReqType(MOEnum):
+    register = auto()
+    change_email = auto()
+    reset_passwd = auto()
+
+
+class RegRequest(Base):
+    __tablename__ = 'reg_requests'
+
+    reg_id = Column(Integer, primary_key=True, server_default=text("nextval('reg_requests_reg_id_seq'::regclass)"))
+    type = Column(Enum(RegReqType, name='reg_req_type'), nullable=False)
+    created_at = Column(DateTime(True), nullable=False)
+    expires_at = Column(DateTime(True), nullable=False)
+    used_at = Column(DateTime(True))
+    captcha_token = Column(Text)
+    email = Column(Text)
+    email_token = Column(Text, nullable=False, unique=True)
+    user_id = Column(Integer, ForeignKey('users.user_id'))
+    client = Column(Text, nullable=False)
+
+    user = relationship('User')
+
+
+class RegionDescendant(Base):
+    __tablename__ = 'region_descendants'
+
+    region = Column(Integer, ForeignKey('places.place_id'), primary_key=True)
+    descendant = Column(Integer, ForeignKey('places.place_id'), primary_key=True)
+
+
+class RegionContestStat(Base):
+    __tablename__ = 'region_contest_stats'
+
+    round_id = Column(Integer, ForeignKey('rounds.round_id'), primary_key=True)
+    region = Column(Integer, ForeignKey('places.place_id'), primary_key=True)
+    state = Column(Enum(RoundState, name='round_state'), primary_key=True)
+    count = Column(Integer, nullable=False)
+
+    round = relationship('Round')
+    region_place = relationship('Place', primaryjoin='RegionContestStat.region == Place.place_id', remote_side='Place.place_id')
+
+
+class RegionParticipantStat(Base):
+    __tablename__ = 'region_participant_stats'
+
+    round_id = Column(Integer, ForeignKey('rounds.round_id'), primary_key=True)
+    region = Column(Integer, ForeignKey('places.place_id'), primary_key=True)
+    state = Column(Enum(PartState, name='part_state'), primary_key=True)
+    count = Column(Integer, nullable=False)
+
+    round = relationship('Round')
+    region_place = relationship('Place', primaryjoin='RegionParticipantStat.region == Place.place_id', remote_side='Place.place_id')
+
+
+class RegionTaskStat(Base):
+    __tablename__ = 'region_task_stats'
+
+    round_id = Column(Integer, ForeignKey('rounds.round_id'), primary_key=True)
+    region = Column(Integer, ForeignKey('places.place_id'), primary_key=True)
+    task_id = Column(Integer, ForeignKey('tasks.task_id'), primary_key=True)
+    count = Column(Integer, nullable=False)
+
+    round = relationship('Round')
+    region_place = relationship('Place', primaryjoin='RegionTaskStat.region == Place.place_id', remote_side='Place.place_id')
+    task = relationship('Task')
+
+
 _engine: Optional[Engine] = None
 _session: Optional[Session] = None
 flask_db: Any = None
@@ -663,22 +776,24 @@ def get_seqs() -> List[int]:
     return [seq for (seq,) in get_session().query(Round.seq).distinct()]
 
 
-def get_place_parents(place: Place) -> List[Place]:
+def get_place_ancestors(place: Place) -> List[Place]:
     """Low-level funkce pro zjištění předků místa.
-    Obvykle voláme mo.rights.Gatekeeper.get_parents(), které kešuje."""
+    Obvykle voláme mo.rights.Gatekeeper.get_ancestors(), které kešuje.
+    Pozor, výsledkem není plnohodnotný objekt Place, ale jen named tuple.
+    """
 
     sess = get_session()
 
     topq = (sess.query(Place)
             .filter(Place.place_id == place.place_id)
-            .cte('parents', recursive=True))
+            .cte('ancestors', recursive=True))
 
     botq = (sess.query(Place)
             .join(topq, Place.place_id == topq.c.parent))
 
     recq = topq.union(botq)
 
-    return sess.query(recq).all()
+    return sorted(sess.query(recq).all(), key=lambda p: p.level)
 
 
 def place_descendant_cte(place: Place, max_level: Optional[int] = None) -> CTE:
@@ -708,6 +823,15 @@ def get_place_descendants(place: Place, min_level: Optional[int] = None, max_lev
     return q.all()
 
 
+def filter_place_nth_parent(query: Query, place_attr: Any, n: int, parent_id: int) -> Query:
+    assert n >= 0
+    for _ in range(n):
+        pp = aliased(Place)
+        query = query.join(pp, pp.place_id == place_attr)
+        place_attr = pp.parent
+    return query.filter(place_attr == parent_id)
+
+
 def get_object_changes(obj):
     """ Given a model instance, returns dict of pending
     changes waiting for database flush/commit.

mo/email.py

+# Rozesílání e-mailových notifikací všeho druhu
+
+import datetime
+import email.message
+import email.headerregistry
+import subprocess
+import textwrap
+import urllib.parse
+
+import mo.db as db
+import mo.config as config
+from mo.util import logger
+
+
+def send_user_email(user: db.User, subject: str, body: str) -> bool:
+    logger.info(f'Mail: "{subject}" -> {user.email}')
+
+    mail_from = getattr(config, 'MAIL_FROM', None)
+    if mail_from is None:
+        logger.error('Mail: V configu chybí nastavení MAIL_FROM')
+        return False
+
+    msg = email.message.EmailMessage()
+    msg['From'] = email.headerregistry.Address(
+        display_name='Odevzdávací Systém MO',
+        addr_spec=mail_from,
+    )
+    msg['To'] = [
+        email.headerregistry.Address(
+            display_name=user.full_name(),
+            addr_spec=user.email,
+        )
+    ]
+    msg['Reply-To'] = email.headerregistry.Address(
+        display_name='Správce OSMO',
+        addr_spec=config.MAIL_CONTACT,
+    )
+    msg['Subject'] = 'OSMO – ' + subject
+    msg['Date'] = datetime.datetime.now()
+
+    msg.set_content(body, cte='quoted-printable')
+
+    mail_instead = getattr(config, 'MAIL_INSTEAD', None)
+    if mail_instead is None:
+        send_to = user.email
+    else:
+        send_to = mail_instead
+
+    sm = subprocess.Popen(
+        [
+            '/usr/sbin/sendmail',
+            '-oi',
+            '-f',
+            mail_from,
+            send_to,
+        ],
+        stdin=subprocess.PIPE,
+    )
+    sm.communicate(msg.as_bytes())
+
+    if sm.returncode != 0:
+        logger.error('Mail: Sendmail failed with return code {}'.format(sm.returncode))
+        return False
+
+    return True
+
+
+def activate_url(token: str) -> str:
+    return config.WEB_ROOT + 'acct/activate?' + urllib.parse.urlencode({'token': token}, safe=':')
+
+
+def confirm_url(type: str, token: str) -> str:
+    return config.WEB_ROOT + f'acct/confirm/{type}?' + urllib.parse.urlencode({'token': token}, safe=':')
+
+
+def contestant_list_url(contest: db.Contest, registered_only: bool) -> str:
+    url = config.WEB_ROOT + f'org/contest/c/{contest.contest_id}/ucastnici'
+    if registered_only:
+        url += '?participation_state=registered'
+    return url
+
+
+def send_new_account_email(user: db.User, token: str) -> bool:
+    return send_user_email(user, 'Založen nový účet', textwrap.dedent('''\
+        Vítejte!
+
+        Právě Vám byl založen účet v Odevzdávacím systému Matematické olympiády.
+        Nastavte si prosím heslo na následující stránce:
+
+                {}
+
+        Váš OSMO
+    '''.format(activate_url(token))))
+
+
+def send_password_reset_email(user: db.User, token: str) -> bool:
+    return send_user_email(user, 'Obnova hesla', textwrap.dedent('''\
+        Někdo (pravděpodobně Vy) požádal o obnovení hesla k Vašemu účtu v Odevzdávacím
+        systému Matematické olympiády. Heslo si můžete nastavit, případně požadavek
+        zrušit, na následující stránce:
+
+                {}
+
+        Váš OSMO
+    '''.format(confirm_url('p', token))))
+
+
+def send_confirm_create_email(user: db.User, token: str) -> bool:
+    return send_user_email(user, 'Založení účtu', textwrap.dedent('''\
+        Někdo (pravděpodobně Vy) požádal o založení účtu s touto e-mailovou adresou
+        v Odevzdávacím systému Matematické olympiády. Pokud účet chcete založit,
+        následujte tento odkaz:
+
+                {}
+
+        Váš OSMO
+    '''.format(confirm_url('r', token))))
+
+
+def send_confirm_change_email(user: db.User, token: str) -> bool:
+    return send_user_email(user, 'Změna e-mailové adresy', textwrap.dedent('''\
+        Někdo (pravděpodobně Vy) požádal o nastavení e-mailové adresy k účtu
+        v Odevzdávacím systému Matematické olympiády na tuto adresu.
+        Pokud změnu chcete provést, následujte tento odkaz:
+
+                {}
+
+        Váš OSMO
+    '''.format(confirm_url('e', token))))
+
+
+def send_join_notify_email(dest: db.User, who: db.User, contest: db.Contest) -> bool:
+    round = contest.round
+    place = contest.place
+    if contest.round.enroll_mode == db.RoundEnrollMode.confirm:
+        confirm = 'Přihlášku je potřeba potvrdit v seznamu účastníků soutěže.'
+        url = 'Přihlášky k potvrzení: ' + contestant_list_url(contest, True)
+    else:
+        confirm = 'Přihláška byla schválena automaticky.'
+        url = 'Seznam účastníků: ' + contestant_list_url(contest, False)
+
+    return send_user_email(dest, f'Nový účastník kategorie {round.category}', textwrap.dedent(f'''\
+        Nový účastník se přihlásil do MO v oblasti, kterou garantujete.
+
+        Jméno:      {who.full_name()}
+        E-mail:     {who.email}
+        Kategorie:  {round.category}
+        Kolo:       {round.name}
+        Místo:      {place.name}
+
+        {confirm}
+
+        {url}
+
+        Váš OSMO
+    '''))

mo/imports.py

@@ -5,11 +5,13 @@ import io
 import re
 from sqlalchemy import and_
 from sqlalchemy.orm import joinedload, Query
-from typing import List, Optional, Any, Dict, Type, Union
+from typing import List, Optional, Any, Dict, Type, Union, Set
 
+import mo.config as config
 import mo.csv
 from mo.csv import FileFormat, MissingHeaderError
 import mo.db as db
+import mo.email
 import mo.rights
 import mo.users
 import mo.util
@@ -55,6 +57,7 @@ class Import:
     user: db.User
     round: Optional[db.Round]
     contest: Optional[db.Contest]
+    only_region: Optional[db.Place]
     task: Optional[db.Task]         # pro Import bodů
     allow_add_del: bool             # pro Import bodů: je povoleno zakládat/mazat řešení
     fmt: FileFormat
@@ -69,6 +72,7 @@ class Import:
     gatekeeper: mo.rights.Gatekeeper
     new_user_ids: List[int]
     line_number: int = 0
+    row_name: Optional[str] = None
 
     def __init__(self):
         self.errors = []
@@ -84,6 +88,9 @@ class Import:
 
     def error(self, msg: str) -> Any:
         if self.line_number > 0:
+            if self.row_name:
+                msg = f"Řádek {self.line_number} ({self.row_name}): {msg}"
+            else:
                 msg = f"Řádek {self.line_number}: {msg}"
         self.errors.append(msg)
         logger.info('Import: >> %s', msg)
@@ -145,21 +152,16 @@ class Import:
         return place
 
     def parse_school(self, kod: str) -> Optional[db.Place]:
-        if kod == "":
-            return self.error('Škola je povinná')
-
         if kod in self.school_place_cache:
             return self.school_place_cache[kod]
 
-        place = db.get_place_by_code(kod, fetch_school=True)
-        if not place:
-            return self.error(f'Škola s kódem "{kod}" nenalezena'+
-                    ('. Nechybí vám # na začátku?' if re.fullmatch(r'\d+', kod) else ''))
-
-        if place.type != db.PlaceType.school:
-            return self.error(f'Kód školy "{kod}" neodpovídá škole')
+        try:
+            place = mo.users.validate_and_find_school(kod)
+        except mo.CheckError as e:
+            return self.error(str(e))
 
         self.school_place_cache[kod] = place
+
         return place
 
     def parse_grade(self, rocnik: str, school: Optional[db.School]) -> Optional[str]:
@@ -170,48 +172,30 @@ class Import:
         # lidé připisují všechny možné i nemožné znaky, které vypadají jako apostrof :)
         rocnik = re.sub('[\'"\u00b4\u2019]', "", rocnik)
 
-        if (not re.fullmatch(r'\d(/\d)?', rocnik)):
-            return self.error(f'Ročník má neplatný formát, musí to být buď číslice, nebo číslice/číslice')
-
-        if (not school.is_zs and re.fullmatch(r'\d', rocnik)):
-            return self.error(f'Ročník pro střední školu ({school.place.name}) zapisujte ve formátu číslice/číslice')
-
-        if (not school.is_ss and re.fullmatch(r'\d/\d', rocnik)):
-            return self.error(f'Ročník pro základní školu ({school.place.name}) zapisujte jako číslici 1–9')
-
-        return rocnik
+        try:
+            return mo.users.normalize_grade(rocnik, school)
+        except mo.CheckError as e:
+            return self.error(str(e))
 
     def parse_born(self, rok: str) -> Optional[int]:
         if not re.fullmatch(r'\d{4}', rok):
             return self.error('Rok narození musí být čtyřciferné číslo')
 
         r = int(rok)
-        if r < 2000 or r > 2099:
-            return self.error('Rok narození musí být v intervalu [2000,2099]')
+
+        try:
+            mo.users.validate_born_year(r)
+        except mo.CheckError as e:
+            return self.error(str(e))
 
         return r
 
-    def find_or_create_user(self, email: str, krestni: str, prijmeni: str, is_org: bool) -> Optional[db.User]:
-        sess = db.get_session()
-        user = sess.query(db.User).filter_by(email=email).one_or_none()
-        if user:
-            if user.first_name != krestni or user.last_name != prijmeni:
-                return self.error(f'Osoba již registrována s odlišným jménem {user.full_name()}')
-            if (user.is_admin or user.is_org) != is_org:
-                if is_org:
-                    return self.error('Nelze předefinovat účastníka na organizátora')
-                else:
-                    return self.error('Nelze předefinovat organizátora na účastníka')
-        else:
-            user = db.User(email=email, first_name=krestni, last_name=prijmeni, is_org=is_org)
-            sess.add(user)
-            sess.flush()    # Aby uživatel dostal user_id
-            logger.info(f'Import: Založen uživatel user=#{user.user_id} email=<{user.email}>')
-            mo.util.log(
-                type=db.LogType.user,
-                what=user.user_id,
-                details={'action': 'import', 'new': db.row2dict(user)},
-            )
+    def find_or_create_user(self, email: str, krestni: Optional[str], prijmeni: Optional[str], is_org: bool) -> Optional[db.User]:
+        try:
+            user, is_new = mo.users.find_or_create_user(email, krestni, prijmeni, is_org, reason='import')
+        except mo.CheckError as e:
+            return self.error(str(e))
+        if is_new:
             self.cnt_new_users += 1
             self.new_user_ids.append(user.user_id)
         return user
@@ -230,69 +214,48 @@ class Import:
 
         return pts
 
-    def find_or_create_participant(self, user: db.User, year: int, school_id: int, birth_year: int, grade: str) -> Optional[db.Participant]:
-        sess = db.get_session()
-        part = sess.query(db.Participant).get((user.user_id, year))
-        if part:
-            if (part.school != school_id
-                    or part.grade != grade
-                    or part.birth_year != birth_year):
-                return self.error('Účastník již zaregistrován s odlišnou školou/ročníkem/rokem narození')
-        else:
-            part = db.Participant(user=user, year=year, school=school_id, birth_year=birth_year, grade=grade)
-            sess.add(part)
-            logger.info(f'Import: Založen účastník #{user.user_id}')
-            mo.util.log(
-                type=db.LogType.participant,
-                what=user.user_id,
-                details={'action': 'import', 'new': db.row2dict(part)},
-            )
+    def find_or_create_participant(self, user: db.User, year: int, school_id: Optional[int], birth_year: Optional[int], grade: Optional[str]) -> Optional[db.Participant]:
+        try:
+            part, is_new = mo.users.find_or_create_participant(user, year, school_id, birth_year, grade, reason='import')
+        except mo.CheckError as e:
+            return self.error(str(e))
+        if is_new:
             self.cnt_new_participants += 1
-
         return part
 
     def find_or_create_participation(self, user: db.User, contest: db.Contest, place: Optional[db.Place]) -> Optional[db.Participation]:
-        if place is None:
-            place = contest.place
-
-        sess = db.get_session()
-        pions = (sess.query(db.Participation)
-                 .filter_by(user=user)
-                 .filter(db.Participation.contest.has(db.Contest.round == contest.round))
-                 .all())
-
-        if not pions:
-            pion = db.Participation(user=user, contest=contest, place_id=place.place_id, state=db.PartState.invited)
-            sess.add(pion)
-            logger.info(f'Import: Založena účast user=#{user.user_id} contest=#{contest.contest_id} place=#{place.place_id}')
-            mo.util.log(
-                type=db.LogType.participant,
-                what=user.user_id,
-                details={'action': 'add-to-contest', 'new': db.row2dict(pion)},
-            )
+        try:
+            pion, is_new = mo.users.find_or_create_participation(user, contest, place, reason='import')
+        except mo.CheckError as e:
+            return self.error(str(e))
+        if is_new:
             self.cnt_new_participations += 1
-        elif len(pions) == 1:
-            pion = pions[0]
-            if pion.place != place:
-                return self.error(f'Již se tohoto kola účastní v {contest.round.get_level().name_locative("jiném", "jiné", "jiném")} ({pion.place.get_code()})')
-        else:
-            return self.error('Již se tohoto kola účastní ve vice oblastech, což by nemělo být možné')
-
         return pion
 
+    def place_is_allowed(self, place: db.Place) -> bool:
+        if self.contest is not None and self.contest.place_id != place.place_id:
+            return False
+        if self.only_region is not None and not self.gatekeeper.is_ancestor_of(self.only_region, place):
+            return False
+        return True
+
     def obtain_contest(self, oblast: Optional[db.Place], allow_none: bool = False):
+        assert self.round
+        if oblast is not None and not self.place_is_allowed(oblast):
+            return self.error('Oblast neodpovídá té, do které se importuje')
         if self.contest:
             contest = self.contest
-            if oblast is not None and oblast.place_id != contest.place.place_id:
-                return self.error('Oblast neodpovídá té, do které se importuje')
         else:
+            # Zde mluvíme o oblastech, místo abychom používali place_levels,
+            # protože sloupec má ve jménu oblast a také je potřeba rozlišovat školu
+            # účastníka a školu jako oblast.
             if oblast is None:
                 if not allow_none:
-                    self.error('Je nutné uvést ' + self.round.get_level().name)
+                    self.error('Je nutné uvést kód oblasti')
                 return None
             contest = db.get_session().query(db.Contest).filter_by(round=self.round, place=oblast).one_or_none()
             if contest is None:
-                return self.error('V ' + self.round.get_level().name_locative("uvedeném", "uvedené", "uvedeném") + ' toto kolo neprobíhá')
+                return self.error('V uvedené oblasti toto kolo neprobíhá')
 
         return contest
 
@@ -330,6 +293,8 @@ class Import:
             args.append(f'round=#{self.round.round_id}')
         if self.contest is not None:
             args.append(f'contest=#{self.contest.contest_id}')
+        if self.only_region is not None:
+            args.append(f'region=#{self.only_region.place_id}')
         if self.task is not None:
             args.append(f'task=#{self.task.task_id}')
 
@@ -350,17 +315,21 @@ class Import:
                 args.append(f'{key}={val}')
         logger.info('Import: Hotovo (%s)', " ".join(args))
 
+        details = self.log_details.copy()
+        if self.only_region:
+            details['region'] = self.only_region.place_id
+
         if self.contest is not None:
             mo.util.log(
                 type=db.LogType.contest,
                 what=self.contest.contest_id,
-                details=self.log_details,
+                details=details,
             )
         elif self.round is not None:
             mo.util.log(
                 type=db.LogType.round,
                 what=self.round.round_id,
-                details=self.log_details,
+                details=details,
             )
         else:
             assert False
@@ -376,6 +345,12 @@ class Import:
         except UnicodeDecodeError:
             return False
 
+    def get_row_name(self, row: mo.csv.Row) -> Optional[str]:
+        if hasattr(row, 'email'):
+            return row.email # type: ignore
+                # čtení prvku potomka
+        return None
+
     def generic_import(self, path: str) -> bool:
         charset = self.fmt.get_charset()
         if charset != 'utf-8' and self.check_utf8(path):
@@ -396,12 +371,14 @@ class Import:
 
         self.line_number = 2
         for row in rows:
+            self.row_name = self.get_row_name(row)
             self.cnt_rows += 1
             self.import_row(row)
             if len(self.errors) >= 100:
                 self.errors.append('Import přerušen pro příliš mnoho chyb')
                 break
             self.line_number += 1
+        self.row_name = None
 
         return len(self.errors) == 0
 
@@ -415,9 +392,9 @@ class Import:
         for uid in self.new_user_ids:
             u = sess.query(db.User).get(uid)
             if u and not u.password_hash and not u.reset_at:
-                token = mo.users.ask_reset_password(u)
+                token = mo.users.make_activation_token(u)
                 sess.commit()
-                mo.util.send_new_account_email(u, token)
+                mo.email.send_new_account_email(u, token)
             else:
                 sess.rollback()
 
@@ -475,28 +452,23 @@ class ContestImport(Import):
         assert isinstance(r, ContestImportRow)
         num_prev_errs = len(self.errors)
         email = self.parse_email(r.email)
-        krestni = self.parse_name(r.krestni)
-        prijmeni = self.parse_name(r.prijmeni)
-        school_place = self.parse_school(r.kod_skoly)
-        rocnik = self.parse_grade(r.rocnik, (school_place.school if school_place else None))
-        rok_naroz = self.parse_born(r.rok_naroz)
+        krestni = self.parse_name(r.krestni) if r.krestni else None
+        prijmeni = self.parse_name(r.prijmeni) if r.prijmeni else None
+        school_place = self.parse_school(r.kod_skoly) if r.kod_skoly else None
+        rocnik = self.parse_grade(r.rocnik, (school_place.school if school_place else None)) if r.rocnik else None
+        rok_naroz = self.parse_born(r.rok_naroz) if r.rok_naroz else None
         misto = self.parse_opt_place(r.kod_mista, 'místo')
         oblast = self.parse_opt_place(r.kod_oblasti, 'oblast')
 
         if (len(self.errors) > num_prev_errs
-                or email is None
-                or krestni is None
-                or prijmeni is None
-                or school_place is None
-                or rocnik is None
-                or rok_naroz is None):
+                or email is None):
             return
 
         user = self.find_or_create_user(email, krestni, prijmeni, is_org=False)
         if user is None:
             return
 
-        part = self.find_or_create_participant(user, mo.current_year, school_place.place_id, rok_naroz, rocnik)
+        part = self.find_or_create_participant(user, config.CURRENT_YEAR, school_place.place_id if school_place else None, rok_naroz, rocnik)
         if part is None:
             return
 
@@ -634,6 +606,9 @@ class PointsImport(Import):
             query = query.filter(db.Participation.contest_id == self.contest.master_contest_id)
         else:
             contest_query = sess.query(db.Contest.master_contest_id).filter_by(round=self.round)
+            if self.only_region:
+                assert self.round
+                contest_query = db.filter_place_nth_parent(contest_query, db.Contest.place_id, self.round.level - self.only_region.level, self.only_region.place_id)
             query = query.filter(db.Participation.contest_id.in_(contest_query.subquery()))
 
         return query
@@ -661,7 +636,13 @@ class PointsImport(Import):
         query = self._pion_sol_query().filter(db.Participation.user_id == user_id)
         pion_sols = query.all()
         if not pion_sols:
-            return self.error('Soutěžící nenalezen v tomto kole')
+            if self.contest is not None:
+                msg = self.round.get_level().name_locative('tomto', 'této', 'tomto')
+            elif self.only_region is not None:
+                msg = self.only_region.get_level().name_locative('tomto', 'této', 'tomto')
+            else:
+                msg = 'tomto kole'
+            return self.error(f'Soutěžící nenalezen v {msg}')
         elif len(pion_sols) > 1:
             return self.error('Soutěžící v tomto kole soutěží vícekrát, neumím zpracovat')
         pion, sol = pion_sols[0]
@@ -671,10 +652,6 @@ class PointsImport(Import):
         else:
             contest = sess.query(db.Contest).filter_by(round=self.round, master_contest_id=pion.contest_id).one()
 
-        if self.contest is not None:
-            if contest != self.contest:
-                return self.error('Soutěžící nesoutěží v ' + self.round.get_level().name_locative('tomto', 'této', 'tomto'))
-
         rights = self.gatekeeper.rights_for_contest(contest)
         if not rights.can_edit_points():
             return self.error('Nemáte právo na úpravu bodů')
@@ -755,6 +732,7 @@ def create_import(user: db.User,
                   fmt: FileFormat,
                   round: Optional[db.Round] = None,
                   contest: Optional[db.Contest] = None,
+                  only_region: Optional[db.Place] = None,
                   task: Optional[db.Task] = None,
                   allow_add_del: bool = False):
     imp: Import
@@ -772,6 +750,7 @@ def create_import(user: db.User,
     imp.user = user
     imp.round = round
     imp.contest = contest
+    imp.only_region = only_region
     imp.task = task
     imp.allow_add_del = allow_add_del
     imp.fmt = fmt

mo/jobs/submit.py

@@ -5,6 +5,7 @@ import os
 import re
 import shutil
 from sqlalchemy import and_
+from sqlalchemy.orm import joinedload
 from tempfile import NamedTemporaryFile
 from typing import List, Optional
 import unicodedata
@@ -84,6 +85,7 @@ def handle_download_submits(the_job: TheJob):
 def schedule_upload_feedback(round: db.Round, tmp_file: str, description: str, for_user: db.User,
                              only_contest: Optional[db.Contest],
                              only_site: Optional[db.Place],
+                             only_region: Optional[db.Place],
                              only_task: Optional[db.Task]):
     the_job = TheJob()
     job = the_job.create(db.JobType.upload_feedback, for_user)
@@ -92,6 +94,7 @@ def schedule_upload_feedback(round: db.Round, tmp_file: str, description: str, f
         'round_id': round.round_id,
         'only_contest_id': only_contest.contest_id if only_contest is not None else None,
         'only_site_id': only_site.place_id if only_site is not None else None,
+        'only_region_id': only_region.place_id if only_region is not None else None,
         'only_task_id': only_task.task_id if only_task is not None else None,
     }
     job.in_file = the_job.attach_file(tmp_file, '.zip')
@@ -165,12 +168,19 @@ def handle_upload_feedback(the_job: TheJob):
     round_id: int = in_json['round_id']  # type: ignore
     only_contest_id: Optional[int] = in_json['only_contest_id']  # type: ignore
     only_site_id: Optional[int] = in_json['only_site_id']  # type: ignore
+    only_region_id: Optional[int] = in_json['only_region_id']  # type: ignore
     only_task_id: Optional[int] = in_json['only_task_id']  # type: ignore
 
     sess = db.get_session()
     round = sess.query(db.Round).get(round_id)
     assert round is not None
 
+    if only_region_id is not None:
+        only_region = sess.query(db.Place).get(only_region_id)
+        assert only_region is not None
+    else:
+        only_region = None
+
     files: List[UploadFeedback] = []
 
     def parse_zip(in_path: str):
@@ -219,6 +229,7 @@ def handle_upload_feedback(the_job: TheJob):
                 .join(db.Contest, db.Contest.master_contest_id == db.Participation.contest_id)
                 .filter(db.Contest.round == round)
                 .filter(db.Participation.user_id.in_(user_dict.keys()))
+                .options(joinedload(db.Contest.place))
                 .all())
 
         user_rights = {}
@@ -237,6 +248,8 @@ def handle_upload_feedback(the_job: TheJob):
                 the_job.error(f'{f.file_name}: Účastník leží mimo vybranou soutěž')
             elif only_site_id is not None and site_id_dict[f.user_id] != only_site_id:
                 the_job.error(f'{f.file_name}: Účastník leží mimo vybrané soutěžní místo')
+            elif only_region is not None and not the_job.gatekeeper.is_ancestor_of(only_region, contest_dict[f.user_id].place):
+                the_job.error(f'{f.file_name}: Účastník leží mimo vybraný region')
             elif not user_rights[f.user_id]:
                 the_job.error(f'{f.file_name}: K tomuto účastníkovi nemáte dostatečná oprávnění')
 

mo/rights.py

@@ -167,7 +167,7 @@ class Rights:
         return right in self.rights
 
     def get_roles(self) -> List[db.RoleType]:
-        """Seznam unikátních rolí, stříděných od nejvýznamnější."""
+        """Seznam unikátních rolí, setříděných od nejvýznamnější."""
         role_set = set(ur.role for ur in self.user_roles)
         return sorted(role_set, key=lambda r: role_order_by_type[r])
 
@@ -198,31 +198,6 @@ class Rights:
             return self.have_right(Right.edit_orgs)
         return self.have_right(Right.edit_users)
 
-    # Interní rozhodovaní o dostupnosti zadání
-
-    def _check_view_statement(self, round: db.Round):
-        if round.tasks_file is None:
-            return False
-
-        if self.have_right(Right.manage_round):
-            # Správce kola může vždy všechno
-            return True
-
-        # Pokud už soutěž skončila, přístup k zadání má každý org.
-        # XXX: Rozhodujeme podle stavu kola, nikoliv soutěže!
-        if round.state in [db.RoundState.grading, db.RoundState.closed]:
-            return True
-
-        # Od stanoveného času vidí zadání orgové s právem view_statement.
-        if (self.have_right(Right.view_statement)
-                and round.state != db.RoundState.preparing
-                and round.pr_tasks_start is not None
-                and mo.now >= round.pr_tasks_start):
-            return True
-
-        # Ve zbylých případech jsme konzervativní a zadání neukazujeme
-        return False
-
 
 class RoundRights(Rights):
     """Práva ke kolu."""
@@ -237,8 +212,11 @@ class RoundRights(Rights):
     # Metody offer_* testují, zda se má v UI nabízet příslušná funkce.
     # Skutečnou kontrolu práv dělá až implementace funkce podle stavu soutěže.
 
+    def _get_state(self) -> db.RoundState:
+        return self.round.state
+
     def _is_active(self) -> bool:
-        return self.round.state not in [db.RoundState.preparing, db.RoundState.closed]
+        return self._get_state() not in [db.RoundState.preparing, db.RoundState.closed]
 
     def offer_upload_solutions(self) -> bool:
         return (self.have_right(Right.upload_submits)
@@ -252,11 +230,47 @@ class RoundRights(Rights):
         return (self.have_right(Right.manage_contest)
                 or (self.have_right(Right.edit_points) and self._is_active()))
 
-    def can_view_statement(self) -> bool:
-        return self._check_view_statement(self.round)
+    def can_upload_solutions(self) -> bool:
+        return (self.have_right(Right.upload_submits)
+                or self.have_right(Right.upload_solutions) and self._get_state() == db.RoundState.running)
+
+    def can_upload_feedback(self) -> bool:
+        return (self.have_right(Right.upload_submits)
+                or self.have_right(Right.upload_feedback) and self._get_state() == db.RoundState.grading)
+
+    def can_edit_points(self) -> bool:
+        return (self.have_right(Right.edit_points) and self._get_state() == db.RoundState.grading
+                or self.have_right(Right.manage_contest))
 
+    def can_create_solutions(self) -> bool:
+        return self.can_upload_solutions() or self.can_upload_feedback()
 
-class ContestRights(Rights):
+    def can_view_statement(self):
+        round = self.round
+        if round.tasks_file is None:
+            return False
+
+        if self.have_right(Right.manage_round):
+            # Správce kola může vždy všechno
+            return True
+
+        # Pokud už soutěž skončila, přístup k zadání má každý org.
+        # XXX: Rozhodujeme podle stavu kola, nikoliv soutěže!
+        if round.state in [db.RoundState.grading, db.RoundState.closed]:
+            return True
+
+        # Od stanoveného času vidí zadání orgové s právem view_statement.
+        if (self.have_right(Right.view_statement)
+                and round.state != db.RoundState.preparing
+                and round.pr_tasks_start is not None
+                and mo.now >= round.pr_tasks_start):
+            return True
+
+        # Ve zbylých případech jsme konzervativní a zadání neukazujeme
+        return False
+
+
+class ContestRights(RoundRights):
     """Práva k soutěži."""
 
     contest: db.Contest
@@ -264,22 +278,10 @@ class ContestRights(Rights):
     def __repr__(self):
         ros = " ".join([r.role.name for r in self.user_roles])
         ris = " ".join([r.name for r in self.rights])
-        return f"ContestRights(uid={self.user.user_id} is_admin={self.user.is_admin} contest=#{self.contest.contest_id} roles=<{ros}> rights=<{ris}>)"
-
-    def can_upload_solutions(self) -> bool:
-        return (self.have_right(Right.upload_submits)
-                or self.have_right(Right.upload_solutions) and self.contest.state == db.RoundState.running)
-
-    def can_upload_feedback(self) -> bool:
-        return (self.have_right(Right.upload_submits)
-                or self.have_right(Right.upload_feedback) and self.contest.state == db.RoundState.grading)
+        return f"ContestRights(uid={self.user.user_id} is_admin={self.user.is_admin} round=#{self.round.round_id} contest=#{self.contest.contest_id} roles=<{ros}> rights=<{ris}>)"
 
-    def can_edit_points(self) -> bool:
-        return (self.have_right(Right.edit_points) and self.contest.state == db.RoundState.grading
-                or self.have_right(Right.manage_contest))
-
-    def can_view_statement(self) -> bool:
-        return self._check_view_statement(self.contest.round)
+    def _get_state(self) -> db.RoundState:
+        return self.contest.state
 
 
 class Gatekeeper:
@@ -299,12 +301,17 @@ class Gatekeeper:
         self.parent_cache = {}
         self.rights_cache = {}
 
-    def get_parents(self, place: db.Place) -> List[db.Place]:
+    def get_ancestors(self, place: db.Place) -> List[db.Place]:
         pid = place.place_id
         if pid not in self.parent_cache:
-            self.parent_cache[pid] = db.get_place_parents(place)
+            self.parent_cache[pid] = db.get_place_ancestors(place)
         return self.parent_cache[pid]
 
+    def is_ancestor_of(self, ancestor: db.Place, of: db.Place) -> bool:
+        ancestors = self.get_ancestors(of)
+        parent_ids = set(p.place_id for p in ancestors)
+        return ancestor.place_id in parent_ids
+
     def rights_for(
             self, place: Optional[db.Place] = None, year: Optional[int] = None,
             cat: Optional[str] = None, seq: Optional[int] = None,
@@ -325,10 +332,7 @@ class Gatekeeper:
         rights.rights = set()
 
         def try_role(role: db.UserRole, at: Optional[db.Place]):
-            if ((at is None or role.place_id == at.place_id)
-                    and (role.year is None or year is None or role.year == year)
-                    and (role.category is None or cat is None or role.category == cat or (role.category == 'Z' and cat.startswith('Z')))
-                    and (role.seq is None or seq is None or role.seq == seq)
+            if (role.applies_to(at=at, year=year, cat=cat, seq=seq)
                     and (min_role is None or role_order_by_type[min_role] >= role_order_by_type[role.role])):
                 rights.user_roles.append(role)
                 r = roles_by_type[role.role]
@@ -339,7 +343,7 @@ class Gatekeeper:
             for role in self.roles:
                 try_role(role, None)
         else:
-            for at in self.get_parents(place):
+            for at in self.get_ancestors(place):
                 for role in self.roles:
                     try_role(role, at)
 
@@ -350,9 +354,11 @@ class Gatekeeper:
         """Posbírá role a práva, ale ignoruje omezení rolí na místa a soutěže. Hodí se pro práva k editaci uživatelů apod."""
         return self.rights_for()
 
-    def rights_for_round(self, round: db.Round, any_place: bool) -> RoundRights:
+    def rights_for_round(self, round: db.Round, any_place: bool = False, for_place: Optional[db.Place] = None) -> RoundRights:
         if any_place:
             place = None
+        elif for_place:
+            place = for_place
         else:
             place = db.get_root_place()
         rights = RoundRights()
@@ -367,6 +373,7 @@ class Gatekeeper:
 
     def rights_for_contest(self, contest: db.Contest, site: Optional[db.Place] = None) -> ContestRights:
         rights = ContestRights()
+        rights.round = contest.round
         rights.contest = contest
         rights._clone_from(self.rights_for(
             place=site or contest.place,

mo/score.py

@@ -106,7 +106,7 @@ class Score:
     def __init__(
         self, round: db.Round, contest: Optional[db.Contest] = None,
         # Ze kterých stavů chceme výsledkovku počítat
-        part_states: List[db.PartState] = [db.PartState.registered, db.PartState.invited, db.PartState.present],
+        part_states: List[db.PartState] = [db.PartState.registered, db.PartState.active],
     ):
         self.round = round
         self.contest = contest

mo/tokens.py

 # Podepsané tokeny
 
+import hashlib
 import hmac
 import urllib.parse
 from typing import Optional, List
@@ -8,9 +9,7 @@ import mo.config as config
 
 
 def _sign_token(token: str, use: str) -> str:
-    key = '-'.join(('sign-token', use, config.SECRET_KEY))
-    mac = hmac.HMAC(key.encode('us-ascii'), token.encode('us-ascii'), 'sha256')
-    return mac.hexdigest()[:16]
+    return sign(token, 'token-' + use)
 
 
 def sign_token(fields: List[str], use: str) -> str:
@@ -27,3 +26,18 @@ def verify_token(token: str, use: str) -> Optional[List[str]]:
     if _sign_token(':'.join(enc_fields), use) != sign:
         return None
     return [urllib.parse.unquote(f) for f in enc_fields]
+
+
+def sign(msg: str, use: str) -> str:
+    """Podpis parametrizovaný tajným klíčem a účelem."""
+
+    key = use + '#' + config.SECRET_KEY
+    mac = hmac.HMAC(key.encode('us-ascii'), msg.encode('us-ascii'), 'sha256')
+    return mac.hexdigest()[:16]
+
+
+def hash(msg: str, use: str) -> str:
+    """Hešovací funkce parametrizovaná tajným klíčem a účelem."""
+
+    m = '#'.join((use, config.SECRET_KEY, msg)).encode('us-ascii')
+    return hashlib.sha256(m).hexdigest()

mo/users.py

@@ -2,17 +2,140 @@
 
 import bcrypt
 import datetime
+import dateutil.tz
 import email.errors
 import email.headerregistry
 import re
-from typing import Optional
+import secrets
+from typing import Optional, Tuple
 
 import mo
+import mo.config as config
 import mo.db as db
 import mo.util
+from mo.util import logger
 import mo.tokens
 
 
+def normalize_grade(rocnik: str, school: db.School) -> str:
+    """ Aktuálně provádí jen kontrolu formátu. """
+
+    if not re.fullmatch(r'\d(/\d)?', rocnik):
+        raise mo.CheckError('Ročník má neplatný formát, musí to být buď číslice, nebo číslice/číslice')
+
+    if not school.is_zs and re.fullmatch(r'\d', rocnik):
+        raise mo.CheckError(f'Ročník pro střední školu ({school.place.name}) zapisujte ve formátu číslice/číslice')
+
+    if not school.is_ss and re.fullmatch(r'\d/\d', rocnik):
+        raise mo.CheckError(f'Ročník pro základní školu ({school.place.name}) zapisujte jako číslici 1–9')
+
+    return rocnik
+
+
+def validate_born_year(r: int) -> None:
+    if r < 2000 or r > 2099:
+        raise mo.CheckError('Rok narození musí být v intervalu [2000,2099]')
+
+
+def validate_and_find_school(kod: str) -> db.Place:
+    if kod == "":
+        raise mo.CheckError('Škola je povinná')
+
+    place = db.get_place_by_code(kod, fetch_school=True)
+    if not place:
+        raise mo.CheckError(f'Škola s kódem "{kod}" nenalezena' +
+                            ('. Nechybí vám # na začátku?' if re.fullmatch(r'\d+', kod) else ''))
+
+    if place.type != db.PlaceType.school:
+        raise mo.CheckError(f'Kód školy "{kod}" neodpovídá škole')
+
+    return place
+
+
+def find_or_create_user(email: str, krestni: Optional[str], prijmeni: Optional[str], is_org: bool, reason: str) -> Tuple[db.User, bool]:
+    sess = db.get_session()
+    user = sess.query(db.User).filter_by(email=email).one_or_none()
+    is_new = user is None
+    if user is None:  # HACK: Podmínku je nutné zapsat znovu místo užití is_new, jinak si s tím mypy neporadí
+        if not krestni or not prijmeni:
+            raise mo.CheckError('Osoba s daným emailem zatím neexistuje, je nutné uvést její jméno.')
+        user = db.User(email=email, first_name=krestni, last_name=prijmeni, is_org=is_org)
+        sess.add(user)
+        sess.flush()    # Aby uživatel dostal user_id
+        logger.info(f'{reason.title()}: Založen uživatel user=#{user.user_id} email=<{user.email}>')
+        mo.util.log(
+            type=db.LogType.user,
+            what=user.user_id,
+            details={'action': 'create-user', 'reason': reason, 'new': db.row2dict(user)},
+        )
+    else:
+        if (krestni and user.first_name != krestni) or (prijmeni and user.last_name != prijmeni):
+            raise mo.CheckError(f'Osoba již registrována s odlišným jménem {user.full_name()}')
+        if (user.is_admin or user.is_org) != is_org:
+            if is_org:
+                raise mo.CheckError('Nelze předefinovat účastníka na organizátora')
+            else:
+                raise mo.CheckError('Nelze předefinovat organizátora na účastníka')
+    return user, is_new
+
+
+def find_or_create_participant(user: db.User, year: int, school_id: Optional[int], birth_year: Optional[int], grade: Optional[str], reason: str) -> Tuple[db.Participant, bool]:
+    sess = db.get_session()
+    part = sess.query(db.Participant).get((user.user_id, year))
+    is_new = part is None
+    if part is None:
+        if not school_id:
+            raise mo.CheckError('Osoba s daným emailem zatím není zaregistrovaná do ročníku, je nutné uvést školu.')
+        if not birth_year:
+            raise mo.CheckError('Osoba s daným emailem zatím není zaregistrovaná do ročníku, je nutné uvést rok narození.')
+        if not grade:
+            raise mo.CheckError('Osoba s daným emailem zatím není zaregistrovaná do ročníku, je nutné uvést ročník.')
+        part = db.Participant(user=user, year=year, school=school_id, birth_year=birth_year, grade=grade)
+        sess.add(part)
+        logger.info(f'{reason.title()}: Založen účastník #{user.user_id}')
+        mo.util.log(
+            type=db.LogType.participant,
+            what=user.user_id,
+            details={'action': 'create-participant', 'reason': reason, 'new': db.row2dict(part)},
+        )
+    else:
+        if ((school_id and part.school != school_id)
+                or (grade and part.grade != grade)
+                or (birth_year and part.birth_year != birth_year)):
+            raise mo.CheckError('Účastník již zaregistrován s odlišnou školou/ročníkem/rokem narození')
+    return part, is_new
+
+
+def find_or_create_participation(user: db.User, contest: db.Contest, place: Optional[db.Place], reason: str) -> Tuple[db.Participation, bool]:
+    if place is None:
+        place = contest.place
+
+    sess = db.get_session()
+    pions = (sess.query(db.Participation)
+             .filter_by(user=user)
+             .filter(db.Participation.contest.has(db.Contest.round == contest.round))
+             .all())
+
+    is_new = pions == []
+    if is_new:
+        pion = db.Participation(user=user, contest=contest, place_id=place.place_id, state=db.PartState.active)
+        sess.add(pion)
+        logger.info(f'{reason.title()}: Založena účast user=#{user.user_id} contest=#{contest.contest_id} place=#{place.place_id}')
+        mo.util.log(
+            type=db.LogType.participant,
+            what=user.user_id,
+            details={'action': 'add-to-contest', 'reason': reason, 'new': db.row2dict(pion)},
+        )
+    elif len(pions) == 1:
+        pion = pions[0]
+        if pion.place != place:
+            raise mo.CheckError(f'Již se tohoto kola účastní v {contest.round.get_level().name_locative("jiném", "jiné", "jiném")} ({pion.place.get_code()})')
+    else:
+        raise mo.CheckError('Již se tohoto kola účastní ve více oblastech, což by nemělo být možné')
+
+    return pion, is_new
+
+
 def normalize_email(addr: str) -> str:
     if not re.fullmatch(r'.+@.+', addr):
         raise mo.CheckError('V e-mailové adrese chybí zavináč')
@@ -53,17 +176,23 @@ def user_by_uid(uid: int) -> db.User:
     return db.get_session().query(db.User).get(uid)
 
 
-def set_password(user: db.User, passwd: str):
+password_help = 'Heslo musí mít alespoň 8 znaků. Doporučujeme kombinovat velká a malá písmena a číslice.'
+
+
+def validate_password(passwd: str) -> bool:
+    return len(passwd) >= 8
+
+
+def set_password(user: db.User, passwd: str, reset: bool = False):
     salt = bcrypt.gensalt()
     hashed = bcrypt.hashpw(passwd.encode('utf-8'), salt)
     user.password_hash = hashed.decode('us-ascii')
-    user.reset_at = None
-    user.last_login_at = datetime.datetime.now()
-
+    if reset:
+        user.reset_at = mo.now
         mo.util.log(
             type=db.LogType.user,
             what=user.user_id,
-        details={"action": "set-passwd"},
+            details={'action': 'do-reset'},
         )
 
 
@@ -73,63 +202,68 @@ def check_password(user: db.User, passwd: str):
 
 
 def login(user: db.User):
-    user.last_login_at = datetime.datetime.now()
-    user.reset_at = None
-
-
-def ask_reset_password(user: db.User) -> str:
-    user.reset_at = datetime.datetime.now()
-    when = int(user.reset_at.timestamp())
-    token = mo.tokens.sign_token([str(user.user_id), str(when)], 'reset')
-
-    mo.util.log(
-        type=db.LogType.user,
-        what=user.user_id,
-        details={'action': 'ask-reset'},
-    )
+    user.last_login_at = mo.now
 
-    return token
 
+def make_activation_token(user: db.User) -> str:
+    user.reset_at = mo.now
+    when = int(mo.now.timestamp())
+    return mo.tokens.sign_token([str(user.user_id), str(when)], 'activate')
 
-def check_reset_password(token: str) -> Optional[db.User]:
-    # Někteří klienti při kopírování adresy z mailu do prohlížeče
-    # přidávají divné Unicodové znaky (přepnutí směru psaní atd., viz issue #58).
-    token = re.sub(r'[^!-~]', "", token)
 
-    fields = mo.tokens.verify_token(token, 'reset')
+def check_activation_token(token: str) -> Optional[db.User]:
+    token = mo.util.clean_up_token(token)
+    fields = mo.tokens.verify_token(token, 'activate')
     if not fields or len(fields) != 2:
         return None
-    user = db.get_session().query(db.User).filter_by(user_id=int(fields[0])).first()
+    user_id = int(fields[0])
+    token_time = datetime.datetime.fromtimestamp(int(fields[1]), tz=dateutil.tz.UTC)
 
-    if user.password_hash is None:
-        reset_token_validity_time = datetime.timedelta(days=28)
+    user = user_by_uid(user_id)
+    if not user:
+        return None
+    elif token_time < mo.now - datetime.timedelta(days=28):
+        return None
     else:
-        reset_token_validity_time = datetime.timedelta(hours=24)
+        return user
 
-    now = datetime.datetime.now().astimezone()
 
-    if (user
-            and user.reset_at is not None
-            and fields[1] == str(int(user.reset_at.timestamp()))
-            and now - user.reset_at < reset_token_validity_time):
-        return user
-    else:
+def new_reg_request(type: db.RegReqType, client: str) -> Optional[db.RegRequest]:
+    sess = db.get_session()
+
+    # Zatím jen jednoduchý rate limit, časem možno vylepšit
+    in_last_minute = db.get_count(sess.query(db.RegRequest).filter(db.RegRequest.created_at >= mo.now - datetime.timedelta(minutes=1)))
+    if in_last_minute >= config.REG_MAX_PER_MINUTE:
         return None
 
+    email_token = mo.tokens.sign_token([str(int(mo.now.timestamp())), secrets.token_hex(16)], 'reg-request')
 
-def cancel_reset_password(user: db.User):
-    user.reset_at = None
-    mo.util.log(
-        type=db.LogType.user,
-        what=user.user_id,
-        details={'action': 'cancel-reset'},
+    return db.RegRequest(
+        type=type,
+        created_at=mo.now,
+        expires_at=mo.now + datetime.timedelta(minutes=config.REG_TOKEN_VALIDITY),
+        email_token=email_token,
+        client=client,
     )
 
 
-def do_reset_password(user: db.User):
-    user.reset_at = None
+def expire_reg_requests():
+    sess = db.get_session()
+    conn = sess.connection()
+    table = db.RegRequest.__table__
+    conn.execute(table.delete().where(table.c.expires_at < mo.now))
+    sess.commit()
+
+
+def request_reset_password(user: db.User, client: str) -> Optional[db.RegRequest]:
+    logger.info('Login: Požadavek na reset hesla pro <%s>', user.email)
+    rr = new_reg_request(db.RegReqType.reset_passwd, client)
+    if rr:
+        db.get_session().add(rr)
+        rr.user_id = user.user_id
         mo.util.log(
             type=db.LogType.user,
             what=user.user_id,
-        details={'action': 'do-reset'},
+            details={'action': 'ask-reset'},
         )
+    return rr

mo/util.py

@@ -4,18 +4,13 @@ from dataclasses import dataclass
 import datetime
 import decimal
 import dateutil.tz
-import email.message
-import email.headerregistry
 import locale
 import logging
 import os
 import re
 import secrets
-import subprocess
 import sys
-from typing import Any, Optional, NoReturn, Tuple
-import textwrap
-import urllib.parse
+from typing import Any, Optional, NoReturn, Tuple, List
 
 import mo
 import mo.db as db
@@ -60,88 +55,6 @@ def log(type: db.LogType, what: int, details: Any):
     db.get_session().add(entry)
 
 
-def send_user_email(user: db.User, subject: str, body: str) -> bool:
-    logger.info(f'Mail: "{subject}" -> {user.email}')
-
-    mail_from = getattr(config, 'MAIL_FROM', None)
-    if mail_from is None:
-        logger.error('Mail: V configu chybí nastavení MAIL_FROM')
-        return False
-
-    msg = email.message.EmailMessage()
-    msg['From'] = email.headerregistry.Address(
-        display_name='Odevzdávací Systém MO',
-        addr_spec=mail_from,
-    )
-    msg['To'] = [
-        email.headerregistry.Address(
-            display_name=user.full_name(),
-            addr_spec=user.email,
-        )
-    ]
-    msg['Reply-To'] = email.headerregistry.Address(
-        display_name='Správce OSMO',
-        addr_spec=config.MAIL_CONTACT,
-    )
-    msg['Subject'] = 'OSMO – ' + subject
-    msg['Date'] = datetime.datetime.now()
-
-    msg.set_content(body, cte='quoted-printable')
-
-    mail_instead = getattr(config, 'MAIL_INSTEAD', None)
-    if mail_instead is None:
-        send_to = user.email
-    else:
-        send_to = mail_instead
-
-    sm = subprocess.Popen(
-        [
-            '/usr/sbin/sendmail',
-            '-oi',
-            '-f',
-            mail_from,
-            send_to,
-        ],
-        stdin=subprocess.PIPE,
-    )
-    sm.communicate(msg.as_bytes())
-
-    if sm.returncode != 0:
-        logger.error('Mail: Sendmail failed with return code {}'.format(sm.returncode))
-        return False
-
-    return True
-
-
-def password_reset_url(token: str) -> str:
-    return config.WEB_ROOT + 'auth/reset?' + urllib.parse.urlencode({'token': token}, safe=':')
-
-
-def send_new_account_email(user: db.User, token: str) -> bool:
-    return send_user_email(user, 'Založen nový účet', textwrap.dedent('''\
-        Vítejte!
-
-        Právě Vám byl založen účet v Odevzdávacím systému Matematické olympiády.
-        Nastavte si prosím heslo na následující stránce:
-
-                {}
-
-        Váš OSMO
-    '''.format(password_reset_url(token))))
-
-
-def send_password_reset_email(user: db.User, token: str) -> bool:
-    return send_user_email(user, 'Obnova hesla', textwrap.dedent('''\
-        Někdo (pravděpodobně Vy) požádal o obnovení hesla k Vašemu účtu v Odevzdávacím
-        systému Matematické olympiády. Heslo si můžete nastavit, případně požadavek
-        zrušit, na následující stránce:
-
-                {}
-
-        Váš OSMO
-    '''.format(password_reset_url(token))))
-
-
 def die(msg: str) -> NoReturn:
     print(msg, file=sys.stderr)
     sys.exit(1)
@@ -247,3 +160,34 @@ def check_points(points: decimal.Decimal, for_task: Optional[db.Task] = None, fo
         else:
             return f'Podle nastavení kola zadat body jen s krokem {points_step} (hodnota {points} je neplatná)'
     return None
+
+
+def parse_int_list(a: str, maxim: int = 200) -> List[int]:
+    """Parsuje "1-3,5,7-9" na [1,2,3,5,7,9].
+    Aby nešlo generovat moc velká pole (obrana proti DDoSu),
+    existuje omezení na velikost."""
+    r: List[int] = []
+    for i in a.split(","):
+        b = i.split("-")
+        if len(b) > 2:
+            raise mo.CheckError("Nadměrný počet pomlček")
+        try:
+            c = list(map(int, b))
+        except ValueError:
+            raise mo.CheckError("Převod na číslo se nezdařil")
+        if any(x < 0 or x > maxim for x in c):
+            raise mo.CheckError("Překročen limit na velikost čísla")
+        if len(c) == 2 and c[0] > c[1]:
+            raise mo.CheckError("Větší číslo nemůže být před menším")
+        r += [c[0]] if len(c) == 1 else range(c[0], c[1] + 1)
+    return r
+
+
+def clean_up_token(token: str) -> str:
+    # Někteří klienti při kopírování adresy z mailu do prohlížeče
+    # přidávají divné Unicodové znaky (přepnutí směru psaní atd., viz issue #58).
+    return re.sub(r'[^!-~]', "", token)
+
+
+def star_is_none(x):
+    return None if x == "*" else x

mo/util_format.py

@@ -41,6 +41,13 @@ def timeformat(dt: datetime) -> str:
         return dt.astimezone().strftime("%Y-%m-%d %H:%M")
 
 
+def timeformat_short(dt: datetime) -> str:
+    if dt is None:
+        return '–'
+    else:
+        return dt.astimezone().strftime("%Y-%m-%d")
+
+
 def timedelta(d: datetime, ref: Optional[datetime] = None, descriptive: bool = False) -> str:
     """Vyrábí česky formátované řetězece 'za 3 minuty', 'před 27 dny' a podobně
     z rozdílu daného datetime a referenčního času (například now).

mo/web/__init__.py

@@ -115,6 +115,7 @@ app.assets.add_assets([
     'bootstrap.min.css',
     'mo.css',
     'js/news-reloader.js',
+    'js/osmo.js',
 ])
 
 
@@ -141,7 +142,7 @@ def init_request():
         if not user:
             # Uživatel mezitím přestal existovat
             app.logger.error('Zrušena session pro neexistujícího uživatele uid=%s', session['uid'])
-            return mo.web.auth.logout()
+            return mo.web.acct.logout()
     else:
         user = None
 
@@ -171,18 +172,28 @@ app.before_request(init_request)
 
 ### UWSGI glue ###
 
+# Čas od času se probudíme a spustíme garbage collector:
+#    - projdeme joby pro případ, že by se ztratil signál
+#    - expirujeme zastaralé joby
+#    - expirujeme zastaralé registrační tokeny
+@app.cli.command('gc')
+def gc():
+    """Run garbage collector."""
+
+    mo.now = mo.util.get_now()
+    mo.jobs.process_jobs()
+    mo.users.expire_reg_requests()
+
+
 try:
     import uwsgi
     from uwsgidecorators import timer, signal
 
-    # Čas od času se probudíme a projdeme joby pro případ, že by se ztratil signál.
-    # Také při tom expirujeme zastaralé joby.
-    @timer(config.JOB_GC_PERIOD, target='mule')
+    @timer(config.GC_PERIOD, target='mule')
     def mule_timer(signum):
         # app.logger.debug('Mule: Timer tick')
         with app.app_context():
-            mo.now = mo.util.get_now()
-            mo.jobs.process_jobs()
+            garbage_collect()
 
     # Obykle při vložení jobu dostaneme signál.
     @signal(42, target='mule')
@@ -205,7 +216,8 @@ except ImportError:
 
 
 # Většina webu je v samostatných modulech
-import mo.web.auth
+import mo.web.api
+import mo.web.acct
 import mo.web.jinja
 import mo.web.menu
 import mo.web.misc