fix telegram
This commit is contained in:
Claude Agent
@@ -0,0 +1,856 @@
|
||||
"""
|
||||
Telegram bot handlers for email-based authentication flow
|
||||
"""
|
||||
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
|
||||
from telegram.ext import (
|
||||
ContextTypes,
|
||||
ConversationHandler,
|
||||
CommandHandler,
|
||||
MessageHandler,
|
||||
CallbackQueryHandler,
|
||||
filters
|
||||
)
|
||||
import logging
|
||||
from datetime import datetime
|
||||
import asyncio
|
||||
|
||||
from typing import Optional
|
||||
|
||||
from backend.modules.telegram.auth.email_auth import (
|
||||
is_valid_email_format,
|
||||
verify_email_in_oracle,
|
||||
generate_email_code,
|
||||
generate_session_token,
|
||||
check_rate_limit,
|
||||
clear_rate_limit
|
||||
)
|
||||
from shared.auth.email_server_cache import email_server_cache
|
||||
from backend.modules.telegram.utils.email_service import get_email_service
|
||||
from backend.modules.telegram.db.operations import (
|
||||
create_email_auth_code,
|
||||
get_email_auth_code,
|
||||
get_pending_email_code,
|
||||
mark_email_code_used,
|
||||
increment_failed_attempts,
|
||||
delete_user_email_codes,
|
||||
is_user_authenticated,
|
||||
link_user_to_oracle,
|
||||
create_or_update_user
|
||||
)
|
||||
from backend.modules.telegram.api.client import get_backend_client
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Conversation states
|
||||
AWAITING_EMAIL, AWAITING_CODE, AWAITING_PASSWORD, AWAITING_SERVER_SELECTION = range(4)
|
||||
|
||||
# Constants
|
||||
MAX_CODE_ATTEMPTS = 3
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# HELPER FUNCTIONS
|
||||
# ============================================================================
|
||||
|
||||
async def edit_login_message(
|
||||
context: ContextTypes.DEFAULT_TYPE,
|
||||
chat_id: int,
|
||||
text: str,
|
||||
reply_markup=None,
|
||||
parse_mode="Markdown"
|
||||
):
|
||||
"""
|
||||
Helper function to edit the login message stored in context.
|
||||
If message_id is not stored, creates a new message instead.
|
||||
"""
|
||||
message_id = context.user_data.get('login_message_id')
|
||||
|
||||
if message_id:
|
||||
try:
|
||||
await context.bot.edit_message_text(
|
||||
chat_id=chat_id,
|
||||
message_id=message_id,
|
||||
text=text,
|
||||
reply_markup=reply_markup,
|
||||
parse_mode=parse_mode
|
||||
)
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not edit message {message_id}: {e}")
|
||||
# Fallback: send new message and update ID
|
||||
msg = await context.bot.send_message(
|
||||
chat_id=chat_id,
|
||||
text=text,
|
||||
reply_markup=reply_markup,
|
||||
parse_mode=parse_mode
|
||||
)
|
||||
context.user_data['login_message_id'] = msg.message_id
|
||||
else:
|
||||
# No message ID stored - create new message
|
||||
msg = await context.bot.send_message(
|
||||
chat_id=chat_id,
|
||||
text=text,
|
||||
reply_markup=reply_markup,
|
||||
parse_mode=parse_mode
|
||||
)
|
||||
context.user_data['login_message_id'] = msg.message_id
|
||||
|
||||
|
||||
async def delete_login_message(context: ContextTypes.DEFAULT_TYPE, chat_id: int):
|
||||
"""Delete the login message and clear the message_id from context"""
|
||||
message_id = context.user_data.get('login_message_id')
|
||||
|
||||
if message_id:
|
||||
try:
|
||||
await context.bot.delete_message(chat_id=chat_id, message_id=message_id)
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not delete message {message_id}: {e}")
|
||||
|
||||
# Clear from context
|
||||
context.user_data.pop('login_message_id', None)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ENTRY POINTS: /login command and action:login button
|
||||
# ============================================================================
|
||||
|
||||
async def login_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""
|
||||
Handler pentru /login command
|
||||
Oferă opțiuni de autentificare: Email sau Web App
|
||||
"""
|
||||
user = update.effective_user
|
||||
|
||||
# Check dacă e deja autentificat
|
||||
if await is_user_authenticated(user.id):
|
||||
await update.message.reply_text(
|
||||
"Ești deja autentificat.\n\n"
|
||||
"Folosește:\n"
|
||||
"• /companies - Vezi companiile tale\n"
|
||||
"• /help - Comenzi disponibile\n"
|
||||
"• /unlink - Deautentifică-te"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Check rate limiting (3 requests per hour)
|
||||
if not await check_rate_limit(f"login_{user.id}", max_attempts=3, window_minutes=60):
|
||||
await update.message.reply_text(
|
||||
"Prea multe încercări de autentificare.\n\n"
|
||||
"Te rugăm să aștepți 60 de minute înainte de a încerca din nou."
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Afișează opțiuni de autentificare
|
||||
keyboard = [
|
||||
[InlineKeyboardButton("Login cu Email + Parolă", callback_data="email_login")],
|
||||
[InlineKeyboardButton("Login din Web App", callback_data="web_login_info")],
|
||||
[InlineKeyboardButton("Anulează", callback_data="cancel")]
|
||||
]
|
||||
reply_markup = InlineKeyboardMarkup(keyboard)
|
||||
|
||||
# CREATE message and SAVE message_id
|
||||
msg = await update.message.reply_text(
|
||||
"Alege metoda de autentificare:",
|
||||
reply_markup=reply_markup,
|
||||
parse_mode="Markdown"
|
||||
)
|
||||
|
||||
# Save message ID for future edits
|
||||
context.user_data['login_message_id'] = msg.message_id
|
||||
|
||||
return AWAITING_EMAIL
|
||||
|
||||
|
||||
async def action_login_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""
|
||||
Handler pentru butonul Login din meniu (action:login)
|
||||
Oferă opțiuni de autentificare: Email sau Web App
|
||||
"""
|
||||
query = update.callback_query
|
||||
user = update.effective_user
|
||||
|
||||
logger.info(f"[EMAIL_AUTH] action_login_callback triggered for user {user.id}")
|
||||
|
||||
await query.answer()
|
||||
|
||||
# Check dacă e deja autentificat
|
||||
if await is_user_authenticated(user.id):
|
||||
await query.edit_message_text(
|
||||
"Ești deja autentificat.\n\n"
|
||||
"Folosește:\n"
|
||||
"• /companies - Vezi companiile tale\n"
|
||||
"• /help - Comenzi disponibile\n"
|
||||
"• /unlink - Deautentifică-te"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Check rate limiting (3 requests per hour)
|
||||
if not await check_rate_limit(f"login_{user.id}", max_attempts=3, window_minutes=60):
|
||||
await query.edit_message_text(
|
||||
"Prea multe încercări de autentificare.\n\n"
|
||||
"Te rugăm să aștepți 60 de minute înainte de a încerca din nou."
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Afișează opțiuni de autentificare
|
||||
keyboard = [
|
||||
[InlineKeyboardButton("Login cu Email + Parolă", callback_data="email_login")],
|
||||
[InlineKeyboardButton("Login din Web App", callback_data="web_login_info")],
|
||||
[InlineKeyboardButton("Anulează", callback_data="cancel")]
|
||||
]
|
||||
reply_markup = InlineKeyboardMarkup(keyboard)
|
||||
|
||||
# EDIT existing menu message and SAVE message_id
|
||||
await query.edit_message_text(
|
||||
"Alege metoda de autentificare:",
|
||||
reply_markup=reply_markup,
|
||||
parse_mode="Markdown"
|
||||
)
|
||||
|
||||
# Save message ID for future edits
|
||||
context.user_data['login_message_id'] = query.message.message_id
|
||||
|
||||
return AWAITING_EMAIL
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CALLBACK: Email Login
|
||||
# ============================================================================
|
||||
|
||||
async def email_login_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Callback pentru butonul 'Login cu Email'"""
|
||||
query = update.callback_query
|
||||
user = update.effective_user
|
||||
|
||||
logger.info(f"[EMAIL_AUTH] email_login_callback triggered for user {user.id}")
|
||||
|
||||
await query.answer()
|
||||
|
||||
# IMPORTANT: Salvează message_id înainte de a edita
|
||||
context.user_data['login_message_id'] = query.message.message_id
|
||||
|
||||
# EDIT same message - remove buttons, ask for email
|
||||
await query.edit_message_text(
|
||||
text="Introdu adresa de email ROA:",
|
||||
parse_mode="Markdown"
|
||||
)
|
||||
|
||||
return AWAITING_EMAIL
|
||||
|
||||
|
||||
async def web_login_info_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Info despre web app login"""
|
||||
query = update.callback_query
|
||||
await query.answer()
|
||||
|
||||
await query.edit_message_text(
|
||||
"**Login din Web App**\n\n"
|
||||
"Pentru această metodă:\n\n"
|
||||
"1. Accesează aplicația web ROA2WEB\n"
|
||||
"2. Autentifică-te cu username + parolă\n"
|
||||
"3. Apasă butonul \"Link Telegram\"\n"
|
||||
"4. Copiază codul generat (8 caractere)\n"
|
||||
"5. Trimite-mi codul: /start ABC123XY\n\n"
|
||||
"Vei fi autentificat automat.",
|
||||
parse_mode="Markdown"
|
||||
)
|
||||
|
||||
# IMPORTANT: Salvează message_id pentru ca /start să poată edita același mesaj
|
||||
context.user_data['web_login_message_id'] = query.message.message_id
|
||||
|
||||
return ConversationHandler.END
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# STATE: AWAITING_EMAIL
|
||||
# ============================================================================
|
||||
|
||||
async def _send_email_code(
|
||||
context: ContextTypes.DEFAULT_TYPE,
|
||||
chat_id: int,
|
||||
email: str,
|
||||
server_id: Optional[str],
|
||||
user_id: int
|
||||
) -> int:
|
||||
"""
|
||||
Generate and send email verification code on the specified server.
|
||||
Returns AWAITING_CODE on success or ConversationHandler.END on failure.
|
||||
"""
|
||||
try:
|
||||
# Verify email in Oracle (on specific server if known)
|
||||
username = await verify_email_in_oracle(email, server_id=server_id)
|
||||
|
||||
# IMPORTANT: Generic response to prevent email enumeration
|
||||
# We always say "code sent" even if email doesn't exist
|
||||
if username:
|
||||
code = generate_email_code()
|
||||
code_saved = await create_email_auth_code(
|
||||
code=code,
|
||||
email=email,
|
||||
username=username,
|
||||
telegram_user_id=user_id,
|
||||
expiry_minutes=5
|
||||
)
|
||||
|
||||
if not code_saved:
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text="Eroare la salvarea codului.\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
email_service = get_email_service()
|
||||
email_sent = await email_service.send_auth_code(email, code, username)
|
||||
|
||||
if email_sent:
|
||||
logger.info(f"[EMAIL-AUTH] ✅ Code sent for {email[:3]}***@*** (user {user_id}, server={server_id})")
|
||||
else:
|
||||
logger.error(f"[EMAIL-AUTH] ❌ Failed to send code (user {user_id}, server={server_id})")
|
||||
|
||||
# Wait 1 second for UX (looks like verification happened)
|
||||
await asyncio.sleep(1)
|
||||
|
||||
# ALWAYS show success (prevent enumeration)
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text=f"Cod trimis pe {email}\n\nIntrodu codul primit pe email:",
|
||||
reply_markup=InlineKeyboardMarkup([
|
||||
[InlineKeyboardButton("Retrimite Cod", callback_data=f"resend:{email}")],
|
||||
[InlineKeyboardButton("Anulează", callback_data="cancel")]
|
||||
])
|
||||
)
|
||||
|
||||
context.user_data['pending_email'] = email
|
||||
context.user_data['pending_username'] = username
|
||||
|
||||
return AWAITING_CODE
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error sending email code: {e}", exc_info=True)
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text="Eroare internă.\n\nIncearcă din nou mai târziu."
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
|
||||
async def receive_email(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Handler pentru primirea email-ului"""
|
||||
email = update.message.text.strip().lower()
|
||||
user_id = update.effective_user.id
|
||||
chat_id = update.effective_chat.id
|
||||
|
||||
# ȘTERG mesajul utilizatorului imediat (chat curat)
|
||||
try:
|
||||
await update.message.delete()
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not delete email message: {e}")
|
||||
|
||||
# Validare format email
|
||||
if not is_valid_email_format(email):
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text="Email invalid\n\nIntrodu o adresă validă (nume@domeniu.ro)",
|
||||
reply_markup=InlineKeyboardMarkup([
|
||||
[InlineKeyboardButton("Anulează", callback_data="cancel")]
|
||||
])
|
||||
)
|
||||
return AWAITING_EMAIL
|
||||
|
||||
# Clean up old pending codes
|
||||
existing_code = await get_pending_email_code(user_id)
|
||||
if existing_code:
|
||||
await delete_user_email_codes(user_id)
|
||||
logger.info(f"Deleted existing pending code for user {user_id}")
|
||||
|
||||
# Show loading
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text="Verificare email...",
|
||||
reply_markup=None
|
||||
)
|
||||
|
||||
# Check server cache for multi-server routing
|
||||
try:
|
||||
await email_server_cache.refresh_if_needed()
|
||||
servers = email_server_cache.get_servers_for_email(email)
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not check email server cache: {e}")
|
||||
servers = []
|
||||
|
||||
if len(servers) > 1:
|
||||
# Multiple servers — ask user to select before sending code
|
||||
context.user_data['pending_email'] = email
|
||||
|
||||
try:
|
||||
from backend.config import settings
|
||||
keyboard = []
|
||||
for srv_id in servers:
|
||||
srv = settings.get_oracle_server(srv_id)
|
||||
srv_name = srv.name if srv else srv_id
|
||||
keyboard.append([InlineKeyboardButton(srv_name, callback_data=f"select_server:{srv_id}")])
|
||||
except Exception:
|
||||
# Fallback: use server IDs as labels
|
||||
keyboard = [
|
||||
[InlineKeyboardButton(srv_id, callback_data=f"select_server:{srv_id}")]
|
||||
for srv_id in servers
|
||||
]
|
||||
keyboard.append([InlineKeyboardButton("Anulează", callback_data="cancel")])
|
||||
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text="Email identificat pe mai multe servere.\n\nSelectează serverul pentru autentificare:",
|
||||
reply_markup=InlineKeyboardMarkup(keyboard)
|
||||
)
|
||||
return AWAITING_SERVER_SELECTION
|
||||
|
||||
# Single server or no cache hit — proceed directly
|
||||
server_id = servers[0] if servers else None
|
||||
context.user_data['server_id'] = server_id
|
||||
|
||||
return await _send_email_code(context, chat_id, email, server_id, user_id)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# STATE: AWAITING_SERVER_SELECTION
|
||||
# ============================================================================
|
||||
|
||||
async def handle_server_selected(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Callback pentru selectarea serverului Oracle (mod multi-server)"""
|
||||
query = update.callback_query
|
||||
user_id = update.effective_user.id
|
||||
chat_id = update.effective_chat.id
|
||||
|
||||
await query.answer()
|
||||
|
||||
# Extract server_id from callback data: "select_server:<id>"
|
||||
server_id = query.data.split(":", 1)[1]
|
||||
|
||||
email = context.user_data.get('pending_email')
|
||||
if not email:
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=chat_id,
|
||||
text="Sesiune expirată\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Save selected server to context
|
||||
context.user_data['server_id'] = server_id
|
||||
logger.info(f"[EMAIL-AUTH] User {user_id} selected server '{server_id}' for {email[:3]}***")
|
||||
|
||||
# Clean up old pending codes then send code on selected server
|
||||
await delete_user_email_codes(user_id)
|
||||
|
||||
return await _send_email_code(context, chat_id, email, server_id, user_id)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# STATE: AWAITING_CODE
|
||||
# ============================================================================
|
||||
|
||||
async def receive_code(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Handler pentru primirea codului din email"""
|
||||
code = update.message.text.strip()
|
||||
user_id = update.effective_user.id
|
||||
|
||||
# ȘTERG mesajul utilizatorului imediat (chat curat)
|
||||
try:
|
||||
await update.message.delete()
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not delete code message: {e}")
|
||||
|
||||
# Validare format cod (6 digits)
|
||||
if not (code.isdigit() and len(code) == 6):
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Cod invalid\n\nIntrodu cele 6 cifre din email.",
|
||||
reply_markup=InlineKeyboardMarkup([
|
||||
[InlineKeyboardButton("Retrimite Cod", callback_data=f"resend:{context.user_data.get('pending_email', '')}")],
|
||||
[InlineKeyboardButton("Anulează", callback_data="cancel")]
|
||||
])
|
||||
)
|
||||
return AWAITING_CODE
|
||||
|
||||
# Verifică cod în DB
|
||||
try:
|
||||
code_data = await get_email_auth_code(code)
|
||||
|
||||
if not code_data:
|
||||
# EDIT login message to show error
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Cod invalid sau expirat\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Verificări de securitate
|
||||
|
||||
# 1. Check if already used
|
||||
if code_data['used']:
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Cod deja folosit\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# 2. Check if expired
|
||||
if datetime.now() > code_data['expires_at']:
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Cod expirat\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# 3. Check if belongs to this user
|
||||
if code_data['telegram_user_id'] != user_id:
|
||||
logger.warning(
|
||||
f"User {user_id} tried to use code belonging to "
|
||||
f"user {code_data['telegram_user_id']}"
|
||||
)
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Cod invalid"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# 4. Check failed attempts (max 3)
|
||||
if code_data['failed_attempts'] >= MAX_CODE_ATTEMPTS:
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Prea multe încercări greșite\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Cod valid - Marchează ca folosit
|
||||
await mark_email_code_used(code)
|
||||
|
||||
# Salvează date verificate în context
|
||||
context.user_data['verified_username'] = code_data['oracle_username']
|
||||
context.user_data['verified_email'] = code_data['email']
|
||||
context.user_data['session_token'] = generate_session_token(
|
||||
user_id,
|
||||
code_data['email']
|
||||
)
|
||||
|
||||
# EDIT same message - ask for password
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Cod validat!\n\nIntroduci parola ROA:",
|
||||
reply_markup=None # No buttons for security
|
||||
)
|
||||
|
||||
return AWAITING_PASSWORD
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error validating code: {e}", exc_info=True)
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Eroare la validarea codului.\n\nIncearcă din nou."
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
|
||||
async def resend_code_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Retrimite codul pe email"""
|
||||
query = update.callback_query
|
||||
await query.answer("Retrimitem codul...")
|
||||
|
||||
# Extract email from callback data
|
||||
callback_data = query.data # Format: "resend:email@example.com"
|
||||
if not callback_data.startswith("resend:"):
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Eroare\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
email = callback_data.split(":", 1)[1]
|
||||
user_id = update.effective_user.id
|
||||
|
||||
# Check rate limiting for resend (max 2 per 10 minutes)
|
||||
if not await check_rate_limit(f"resend_{user_id}", max_attempts=2, window_minutes=10):
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Prea multe solicitări\n\nAșteaptă 10 minute."
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Get username from context or re-verify
|
||||
username = context.user_data.get('pending_username')
|
||||
|
||||
if not username:
|
||||
username = await verify_email_in_oracle(email)
|
||||
if not username:
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Eroare\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Delete old code and generate new one
|
||||
await delete_user_email_codes(user_id)
|
||||
|
||||
code = generate_email_code()
|
||||
|
||||
# Save new code
|
||||
await create_email_auth_code(
|
||||
code=code,
|
||||
email=email,
|
||||
username=username,
|
||||
telegram_user_id=user_id,
|
||||
expiry_minutes=5
|
||||
)
|
||||
|
||||
# Send email
|
||||
email_service = get_email_service()
|
||||
await email_service.send_auth_code(email, code, username)
|
||||
|
||||
# FIX BUG: EDIT message and KEEP buttons!
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text=f"Cod retrimis pe {email}\n\nIntrodu codul primit pe email:",
|
||||
reply_markup=InlineKeyboardMarkup([
|
||||
[InlineKeyboardButton("Retrimite Cod", callback_data=f"resend:{email}")],
|
||||
[InlineKeyboardButton("Anulează", callback_data="cancel")]
|
||||
])
|
||||
)
|
||||
|
||||
return AWAITING_CODE
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# STATE: AWAITING_PASSWORD
|
||||
# ============================================================================
|
||||
|
||||
async def receive_password(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Handler pentru primirea parolei Oracle"""
|
||||
password = update.message.text.strip()
|
||||
user_id = update.effective_user.id
|
||||
|
||||
# Șterge IMEDIAT mesajul cu parola (securitate)
|
||||
try:
|
||||
await update.message.delete()
|
||||
logger.info(f"Password message deleted for user {user_id}")
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not delete password message: {e}")
|
||||
|
||||
# Get verified data from context
|
||||
username = context.user_data.get('verified_username')
|
||||
email = context.user_data.get('verified_email')
|
||||
session_token = context.user_data.get('session_token')
|
||||
|
||||
if not all([username, email, session_token]):
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Sesiune expirată\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# EDIT login message to show loading
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Verificare...",
|
||||
reply_markup=None
|
||||
)
|
||||
|
||||
try:
|
||||
# Call backend endpoint pentru verificare parolă + JWT
|
||||
backend_client = get_backend_client()
|
||||
server_id = context.user_data.get('server_id')
|
||||
|
||||
response = await backend_client.login_with_email(
|
||||
email=email,
|
||||
password=password,
|
||||
telegram_user_id=user_id,
|
||||
session_token=session_token,
|
||||
server_id=server_id
|
||||
)
|
||||
|
||||
if not response.get('success'):
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Credențiale invalide\n\nParolă incorectă sau cont inactiv.\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
# Success - Salvează user în telegram_users
|
||||
# First create or update user record
|
||||
await create_or_update_user(
|
||||
telegram_user_id=user_id,
|
||||
username=update.effective_user.username,
|
||||
first_name=update.effective_user.first_name,
|
||||
last_name=update.effective_user.last_name
|
||||
)
|
||||
|
||||
# Then link to Oracle
|
||||
from datetime import datetime, timedelta
|
||||
token_expires_at = datetime.now() + timedelta(minutes=30) # Default expiry
|
||||
|
||||
await link_user_to_oracle(
|
||||
telegram_user_id=user_id,
|
||||
oracle_username=response['username'],
|
||||
jwt_token=response['access_token'],
|
||||
jwt_refresh_token=response['refresh_token'],
|
||||
token_expires_at=token_expires_at
|
||||
)
|
||||
|
||||
# Clear rate limits on successful auth
|
||||
clear_rate_limit(f"login_{user_id}")
|
||||
clear_rate_limit(f"resend_{user_id}")
|
||||
|
||||
# Get session and active company BEFORE editing message
|
||||
from backend.modules.telegram.agent.session import get_session_manager
|
||||
from backend.modules.telegram.bot.menus import create_main_menu, pad_message_for_wide_buttons
|
||||
|
||||
session_manager = get_session_manager()
|
||||
session = await session_manager.get_or_create_session(user_id)
|
||||
company = session.get_active_company()
|
||||
|
||||
company_name = company['name'] if company else None
|
||||
company_cui = company.get('cui') if company else None
|
||||
|
||||
# Create main menu keyboard
|
||||
keyboard = create_main_menu(
|
||||
company_name=company_name,
|
||||
company_cui=company_cui,
|
||||
is_authenticated=True, # Now authenticated
|
||||
cache_enabled=True # Default enabled
|
||||
)
|
||||
|
||||
# Menu message with company info
|
||||
companies_count = len(response.get('companies', []))
|
||||
|
||||
if company_name:
|
||||
menu_text = f"{company_name}"
|
||||
else:
|
||||
menu_text = f"Companii disponibile: {companies_count}\n\nSelectează o companie pentru a continua"
|
||||
|
||||
menu_message = pad_message_for_wide_buttons(menu_text)
|
||||
|
||||
# EDIT login message to show menu (no deletion, direct edit)
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text=menu_message,
|
||||
reply_markup=keyboard
|
||||
)
|
||||
|
||||
# Clear sensitive data from context
|
||||
context.user_data.clear()
|
||||
|
||||
logger.info(f"User {user_id} authenticated successfully via email")
|
||||
|
||||
return ConversationHandler.END
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error during password verification: {e}", exc_info=True)
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Eroare la autentificare.\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
return ConversationHandler.END
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CANCEL HANDLER
|
||||
# ============================================================================
|
||||
|
||||
async def cancel_login(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Cancel conversation"""
|
||||
|
||||
# EDIT login message to show cancellation (don't delete)
|
||||
if update.callback_query:
|
||||
# Called from button
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Login anulat",
|
||||
reply_markup=None
|
||||
)
|
||||
elif update.message:
|
||||
# Called from /cancel command
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Login anulat",
|
||||
reply_markup=None
|
||||
)
|
||||
|
||||
# Clear context
|
||||
context.user_data.clear()
|
||||
|
||||
return ConversationHandler.END
|
||||
|
||||
|
||||
async def conversation_timeout(update: Update, context: ContextTypes.DEFAULT_TYPE):
|
||||
"""Handler for conversation timeout"""
|
||||
|
||||
# EDIT login message to show timeout
|
||||
await edit_login_message(
|
||||
context=context,
|
||||
chat_id=update.effective_chat.id,
|
||||
text="Sesiune expirată\n\nConversația a expirat după 5 minute.\n\nIncearcă din nou cu /login"
|
||||
)
|
||||
|
||||
# Clear context
|
||||
context.user_data.clear()
|
||||
|
||||
return ConversationHandler.END
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONVERSATION HANDLER SETUP
|
||||
# ============================================================================
|
||||
|
||||
email_login_handler = ConversationHandler(
|
||||
entry_points=[
|
||||
CommandHandler('login', login_command),
|
||||
CallbackQueryHandler(action_login_callback, pattern='^action:login$'),
|
||||
CallbackQueryHandler(email_login_callback, pattern='^email_login$')
|
||||
],
|
||||
states={
|
||||
AWAITING_EMAIL: [
|
||||
MessageHandler(filters.TEXT & ~filters.COMMAND, receive_email)
|
||||
],
|
||||
AWAITING_SERVER_SELECTION: [
|
||||
CallbackQueryHandler(handle_server_selected, pattern='^select_server:')
|
||||
],
|
||||
AWAITING_CODE: [
|
||||
MessageHandler(filters.TEXT & ~filters.COMMAND, receive_code),
|
||||
CallbackQueryHandler(resend_code_callback, pattern='^resend:')
|
||||
],
|
||||
AWAITING_PASSWORD: [
|
||||
MessageHandler(filters.TEXT & ~filters.COMMAND, receive_password)
|
||||
],
|
||||
},
|
||||
fallbacks=[
|
||||
CommandHandler('cancel', cancel_login),
|
||||
CallbackQueryHandler(cancel_login, pattern='^cancel$'),
|
||||
CallbackQueryHandler(web_login_info_callback, pattern='^web_login_info$')
|
||||
],
|
||||
per_message=False, # Track conversation per user, not per message
|
||||
allow_reentry=True, # Allow starting new conversation even if previous one is active
|
||||
name="email_login_conversation"
|
||||
)
|
||||
Reference in New Issue
Block a user