Nikolay Tatarinov
7ffa727832
Some checks failed
CI / lint-and-test (push) Failing after 27s
- Added a global exception handler to log unhandled exceptions and return a generic 500 JSON response without exposing details to the client. - Updated the configuration to validate the `DATABASE_URL` format, ensuring it starts with `sqlite://` or `postgresql://`, and log warnings for invalid formats. - Introduced safe parsing for numeric environment variables (`HTTP_PORT`, `INIT_DATA_MAX_AGE_SECONDS`) with defaults on invalid values, including logging warnings for out-of-range values. - Enhanced the duty schedule parser to enforce limits on the number of schedule rows and the length of full names and duty strings, raising appropriate errors when exceeded. - Updated internationalization messages to include generic error responses for import failures and parsing issues, improving user experience. - Added unit tests to verify the new error handling and configuration validation behaviors.
253 lines
9.6 KiB
Python
253 lines
9.6 KiB
Python
"""Command handlers: /start, /help; /start registers user."""
|
|
|
|
import asyncio
|
|
|
|
import duty_teller.config as config
|
|
from telegram import Update
|
|
from telegram.ext import CommandHandler, ContextTypes
|
|
|
|
from duty_teller.db.models import User
|
|
from duty_teller.db.session import session_scope
|
|
from duty_teller.db.repository import (
|
|
get_or_create_user,
|
|
get_user_by_telegram_id,
|
|
get_user_by_username,
|
|
set_user_phone,
|
|
create_calendar_token,
|
|
can_access_miniapp_for_telegram_user,
|
|
set_user_role,
|
|
ROLE_USER,
|
|
ROLE_ADMIN,
|
|
)
|
|
from duty_teller.handlers.common import invalidate_is_admin_cache, is_admin_async
|
|
from duty_teller.i18n import get_lang, t
|
|
from duty_teller.utils.user import build_full_name
|
|
|
|
|
|
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
"""Handle /start: register user in DB and send greeting."""
|
|
if not update.message:
|
|
return
|
|
user = update.effective_user
|
|
if not user:
|
|
return
|
|
full_name = build_full_name(user.first_name, user.last_name)
|
|
telegram_user_id = user.id
|
|
username = user.username
|
|
first_name = user.first_name
|
|
last_name = user.last_name
|
|
|
|
def do_get_or_create() -> None:
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
get_or_create_user(
|
|
session,
|
|
telegram_user_id=telegram_user_id,
|
|
full_name=full_name,
|
|
username=username,
|
|
first_name=first_name,
|
|
last_name=last_name,
|
|
)
|
|
|
|
await asyncio.get_running_loop().run_in_executor(None, do_get_or_create)
|
|
|
|
lang = get_lang(user)
|
|
text = t(lang, "start.greeting")
|
|
await update.message.reply_text(text)
|
|
|
|
|
|
async def set_phone(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
"""Handle /set_phone [number]: set or clear phone (private chat only)."""
|
|
if not update.message or not update.effective_user:
|
|
return
|
|
lang = get_lang(update.effective_user)
|
|
if update.effective_chat and update.effective_chat.type != "private":
|
|
await update.message.reply_text(t(lang, "set_phone.private_only"))
|
|
return
|
|
args = context.args or []
|
|
phone = " ".join(args).strip() if args else None
|
|
telegram_user_id = update.effective_user.id
|
|
|
|
def do_set_phone() -> tuple[str, str | None]:
|
|
"""Returns (status, display_phone). status is 'error'|'saved'|'cleared'. display_phone for 'saved'."""
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
full_name = build_full_name(
|
|
update.effective_user.first_name, update.effective_user.last_name
|
|
)
|
|
get_or_create_user(
|
|
session,
|
|
telegram_user_id=telegram_user_id,
|
|
full_name=full_name,
|
|
username=update.effective_user.username,
|
|
first_name=update.effective_user.first_name,
|
|
last_name=update.effective_user.last_name,
|
|
)
|
|
user = set_user_phone(session, telegram_user_id, phone or None)
|
|
if user is None:
|
|
return ("error", None)
|
|
if phone:
|
|
return ("saved", user.phone or config.normalize_phone(phone))
|
|
return ("cleared", None)
|
|
|
|
result, display_phone = await asyncio.get_running_loop().run_in_executor(
|
|
None, do_set_phone
|
|
)
|
|
if result == "error":
|
|
await update.message.reply_text(t(lang, "set_phone.error"))
|
|
elif result == "saved":
|
|
await update.message.reply_text(
|
|
t(lang, "set_phone.saved", phone=display_phone or "")
|
|
)
|
|
else:
|
|
await update.message.reply_text(t(lang, "set_phone.cleared"))
|
|
|
|
|
|
async def calendar_link(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
"""Handle /calendar_link: send personal ICS URL (private chat only; user must be in allowlist)."""
|
|
if not update.message or not update.effective_user:
|
|
return
|
|
lang = get_lang(update.effective_user)
|
|
if update.effective_chat and update.effective_chat.type != "private":
|
|
await update.message.reply_text(t(lang, "calendar_link.private_only"))
|
|
return
|
|
telegram_user_id = update.effective_user.id
|
|
full_name = build_full_name(
|
|
update.effective_user.first_name, update.effective_user.last_name
|
|
)
|
|
|
|
def do_calendar_link() -> tuple[str | None, str | None]:
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
user = get_or_create_user(
|
|
session,
|
|
telegram_user_id=telegram_user_id,
|
|
full_name=full_name,
|
|
username=update.effective_user.username,
|
|
first_name=update.effective_user.first_name,
|
|
last_name=update.effective_user.last_name,
|
|
)
|
|
if not can_access_miniapp_for_telegram_user(session, telegram_user_id):
|
|
return (None, "denied")
|
|
token = create_calendar_token(session, user.id)
|
|
return (token, None)
|
|
|
|
result_token, error = await asyncio.get_running_loop().run_in_executor(
|
|
None, do_calendar_link
|
|
)
|
|
if error == "denied":
|
|
await update.message.reply_text(t(lang, "calendar_link.access_denied"))
|
|
return
|
|
if not result_token:
|
|
await update.message.reply_text(t(lang, "calendar_link.error"))
|
|
return
|
|
base = (config.MINI_APP_BASE_URL or "").rstrip("/")
|
|
if not base:
|
|
await update.message.reply_text(t(lang, "calendar_link.error"))
|
|
return
|
|
url_personal = f"{base}/api/calendar/ical/{result_token}.ics"
|
|
url_team = f"{base}/api/calendar/ical/team/{result_token}.ics"
|
|
await update.message.reply_text(
|
|
t(
|
|
lang,
|
|
"calendar_link.success",
|
|
url_personal=url_personal,
|
|
url_team=url_team,
|
|
)
|
|
+ "\n\n"
|
|
+ t(lang, "calendar_link.help_hint")
|
|
)
|
|
|
|
|
|
async def help_cmd(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
"""Handle /help: send list of commands (admins see import_duty_schedule)."""
|
|
if not update.message or not update.effective_user:
|
|
return
|
|
lang = get_lang(update.effective_user)
|
|
lines = [
|
|
t(lang, "help.title"),
|
|
t(lang, "help.start"),
|
|
t(lang, "help.help"),
|
|
t(lang, "help.set_phone"),
|
|
t(lang, "help.calendar_link"),
|
|
t(lang, "help.pin_duty"),
|
|
t(lang, "help.refresh_pin"),
|
|
]
|
|
if await is_admin_async(update.effective_user.id):
|
|
lines.append(t(lang, "help.import_schedule"))
|
|
lines.append(t(lang, "help.set_role"))
|
|
lines.append(t(lang, "help.trust_group"))
|
|
lines.append(t(lang, "help.untrust_group"))
|
|
await update.message.reply_text("\n".join(lines))
|
|
|
|
|
|
async def set_role(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
"""Handle /set_role: set user role (admin only). Usage: /set_role @username user|admin or reply + user|admin."""
|
|
if not update.message or not update.effective_user:
|
|
return
|
|
lang = get_lang(update.effective_user)
|
|
if not await is_admin_async(update.effective_user.id):
|
|
await update.message.reply_text(t(lang, "import.admin_only"))
|
|
return
|
|
args = (context.args or [])[:2]
|
|
# Resolve target: reply -> telegram_user_id; or first arg @username / numeric telegram_id
|
|
target_user = None
|
|
role_name = None
|
|
if update.message.reply_to_message and update.message.reply_to_message.from_user:
|
|
target_telegram_id = update.message.reply_to_message.from_user.id
|
|
role_name = (args[0] or "").strip().lower() if args else None
|
|
|
|
def do_get_reply() -> User | None:
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
return get_user_by_telegram_id(session, target_telegram_id)
|
|
|
|
target_user = await asyncio.get_running_loop().run_in_executor(
|
|
None, do_get_reply
|
|
)
|
|
elif len(args) >= 2:
|
|
first = (args[0] or "").strip()
|
|
role_name = (args[1] or "").strip().lower()
|
|
if first.lstrip("@").isdigit():
|
|
target_telegram_id = int(first.lstrip("@"))
|
|
|
|
def do_get_by_tid() -> User | None:
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
return get_user_by_telegram_id(session, target_telegram_id)
|
|
|
|
target_user = await asyncio.get_running_loop().run_in_executor(
|
|
None, do_get_by_tid
|
|
)
|
|
else:
|
|
|
|
def do_get_by_username() -> User | None:
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
return get_user_by_username(session, first)
|
|
|
|
target_user = await asyncio.get_running_loop().run_in_executor(
|
|
None, do_get_by_username
|
|
)
|
|
if not role_name or role_name not in (ROLE_USER, ROLE_ADMIN):
|
|
await update.message.reply_text(t(lang, "set_role.usage"))
|
|
return
|
|
if not target_user:
|
|
await update.message.reply_text(t(lang, "set_role.user_not_found"))
|
|
return
|
|
|
|
def do_set_role() -> bool:
|
|
with session_scope(config.DATABASE_URL) as session:
|
|
updated = set_user_role(session, target_user.id, role_name)
|
|
return updated is not None
|
|
|
|
ok = await asyncio.get_running_loop().run_in_executor(None, do_set_role)
|
|
if ok:
|
|
invalidate_is_admin_cache(target_user.telegram_user_id)
|
|
await update.message.reply_text(
|
|
t(lang, "set_role.done", name=target_user.full_name, role=role_name)
|
|
)
|
|
else:
|
|
await update.message.reply_text(t(lang, "set_role.error"))
|
|
|
|
|
|
start_handler = CommandHandler("start", start)
|
|
help_handler = CommandHandler("help", help_cmd)
|
|
set_phone_handler = CommandHandler("set_phone", set_phone)
|
|
calendar_link_handler = CommandHandler("calendar_link", calendar_link)
|
|
set_role_handler = CommandHandler("set_role", set_role)
|