roa2web-service-auto/TELEGRAM_EMAIL_AUTH_PLAN.md

# Plan: Autentificare Telegram Bot prin Email + Parolă (2FA)

**Data**: 2025-11-07
**Autor**: Claude Code
**Status**: Planificat - Neîmplementat

---

## 🎯 Obiectiv

Implementare autentificare alternativă **email + parolă** pentru Telegram Bot, în **paralel** cu metoda actuală (cod din web app). Ambele metode vor fi disponibile pentru toți utilizatorii.

**Cerințe cheie:**
- ✅ Minimal invaziv - nu modifica logica existentă
- ✅ Ambele metode de autentificare în paralel
- ✅2FA real: email possession + parolă Oracle
- ✅ Simplu de testat cu un singur utilizator (mmarius28@gmail.com)

---

## 📊 Context: Sistemul Actual

### Metoda Actuală de Autentificare (rămâne neschimbată)

```
1. User se autentifică în web app (username + parolă)
2. User cere linking Telegram → backend generează cod 8-char
3. Backend salvează cod în telegram-bot via POST /internal/save-code
4. User trimite /start ABC123XY în Telegram
5. Bot validează codul și auto-linkează (fără parolă din nou)
6. User autentificat în bot
```

**Caracteristici:**
- Nu necesită email
- Necesită acces la web app
- Auto-linking fără re-introducere parolă
- Cod expiră în 15 minute

---

## 🔄 Noul Flux de Autentificare (Email + Parolă)

### Flow Complet

```
┌─────────────────────────────────────────────────────────────┐
│ 1. User: /login SAU apasă buton "🔐 Login cu Email"        │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 2. Bot: "📧 Introdu adresa ta de email Oracle:"            │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 3. User: mmarius28@gmail.com                                │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 4. Bot:                                                      │
│    - Verifică email în Oracle UTILIZATORI table             │
│    - Generează cod 6-digit random                           │
│    - Salvează în email_auth_codes (expiry 5 min)           │
│    - Trimite email SMTP: "Codul tău: 123456"               │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 5. Bot: "✉️ Cod trimis pe email. Introdu codul (5 min):"   │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 6. User: 123456                                              │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 7. Bot:                                                      │
│    - Validează cod în email_auth_codes                      │
│    - Verifică expiry (5 minute)                             │
│    - Marchează cod ca "used"                                │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 8. Bot: "🔐 Introdu parola ta Oracle:"                      │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 9. User: parola_mea (mesaj va fi șters automat)            │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 10. Bot → Backend:                                           │
│     POST /api/telegram/auth/login-with-email                │
│     {                                                        │
│       "email": "mmarius28@gmail.com",                       │
│       "password": "parola_mea",                             │
│       "telegram_user_id": 123456789                         │
│     }                                                        │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 11. Backend:                                                 │
│     - Găsește username din email în UTILIZATORI             │
│     - Verifică parolă: pack_drepturi.verificautilizator()   │
│     - Generează JWT tokens (access + refresh)               │
│     - Returnează tokens + user data                         │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 12. Bot:                                                     │
│     - Salvează JWT în telegram_users table                  │
│     - Linkează telegram_user_id cu oracle_username          │
│     - Șterge mesajele cu parolă                             │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ 13. Bot: "✅ Autentificat cu succes! Folosește /help"      │
└─────────────────────────────────────────────────────────────┘
```

### Conversation States (ConversationHandler)

```python
AWAITING_EMAIL = 1      # Așteaptă email de la user
AWAITING_CODE = 2       # Așteaptă cod din email
AWAITING_PASSWORD = 3   # Așteaptă parolă Oracle
```

---

## 📦 Componente Noi (Arhitectură)

### 1. Email Service (SMTP Client)

**Fișier NOU**: `reports-app/telegram-bot/app/utils/email_service.py`

```python
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import os

class EmailService:
    def __init__(self):
        self.smtp_host = os.getenv("SMTP_HOST", "mail.romfast.ro")
        self.smtp_port = int(os.getenv("SMTP_PORT", "587"))
        self.smtp_user = os.getenv("SMTP_USER", "ups@romfast.ro")
        self.smtp_password = os.getenv("SMTP_PASSWORD", "#Ups2020#")
        self.from_email = os.getenv("SMTP_FROM_EMAIL", "ups@romfast.ro")
        self.from_name = os.getenv("SMTP_FROM_NAME", "ROA2WEB")

    async def send_auth_code(self, to_email: str, code: str, username: str) -> bool:
        """
        Trimite cod de autentificare pe email
        Returns: True dacă email trimis cu succes
        """
        subject = "Codul tău de autentificare ROA2WEB"

        html_body = f"""
        <html>
        <body style="font-family: Arial, sans-serif;">
            <h2>🔐 Autentificare Telegram Bot</h2>
            <p>Salut <strong>{username}</strong>,</p>
            <p>Codul tău de autentificare este:</p>
            <h1 style="background-color: #f0f0f0; padding: 20px; text-align: center; letter-spacing: 5px;">
                {code}
            </h1>
            <p><strong>Codul expiră în 5 minute.</strong></p>
            <p>Dacă nu ai solicitat acest cod, te rugăm să ignori acest email.</p>
            <hr>
            <p style="color: #666; font-size: 12px;">
                ROA2WEB - ERP Reports Application
            </p>
        </body>
        </html>
        """

        # Implementare SMTP cu error handling
```

**Funcții:**
- `send_auth_code(email, code, username)` - trimite cod pe email
- `_send_email(to, subject, html_body)` - helper SMTP generic
- Error handling cu retry logic (3 încercări)

---

### 2. Tabela SQLite Nouă: `email_auth_codes`

**Locație**: `reports-app/telegram-bot/app/db/database.py`

**Schema SQL:**
```sql
CREATE TABLE IF NOT EXISTS email_auth_codes (
    code TEXT PRIMARY KEY,              -- 6-digit numeric code (e.g., "123456")
    email TEXT NOT NULL,                -- Email utilizator din Oracle
    oracle_username TEXT NOT NULL,      -- Username Oracle asociat
    telegram_user_id INTEGER NOT NULL,  -- Telegram user ID care a solicitat
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP NOT NULL,      -- Current time + 5 minute
    used BOOLEAN DEFAULT 0,             -- 0 = nefolosit, 1 = folosit
    used_at TIMESTAMP,                  -- Timestamp când a fost folosit

    -- Index pentru query performance
    INDEX idx_email (email),
    INDEX idx_expires_at (expires_at),
    INDEX idx_telegram_user_id (telegram_user_id)
);
```

**Operații CRUD** (în `app/db/operations.py`):
```python
async def create_email_auth_code(code: str, email: str, username: str, telegram_user_id: int) -> bool
async def get_email_auth_code(code: str) -> Optional[Dict]
async def mark_email_code_used(code: str) -> bool
async def delete_expired_email_codes() -> int
async def get_pending_email_code_for_user(telegram_user_id: int) -> Optional[Dict]
```

**Caracteristici:**
- Cod 6-digit random numeric (000000 - 999999)
- Expirare 5 minute
- One-time use (marcat ca `used=1`)
- Auto-cleanup de către job-ul existent (hourly)

---

### 3. Backend Endpoint NOU: `POST /api/telegram/auth/login-with-email`

**Locație**: `reports-app/backend/app/routers/telegram.py`

**Request Schema:**
```python
class TelegramEmailLoginRequest(BaseModel):
    email: EmailStr
    password: str
    telegram_user_id: int

class TelegramEmailLoginResponse(BaseModel):
    success: bool
    access_token: str
    refresh_token: str
    token_type: str = "bearer"
    user_id: int
    username: str
    companies: List[CompanyInfo]
    message: str
```

**Endpoint Logic:**
```python
@router.post("/auth/login-with-email", response_model=TelegramEmailLoginResponse)
async def login_with_email(request: TelegramEmailLoginRequest):
    """
    Autentificare Telegram prin email + parolă

    Flow:
    1. Caută username în Oracle UTILIZATORI by email
    2. Verifică parolă prin pack_drepturi.verificautilizator(username, password)
    3. Dacă valid: generează JWT tokens
    4. Returnează tokens + user data
    """

    async with oracle_pool.get_connection() as connection:
        # 1. Find username by email
        cursor = connection.cursor()
        cursor.execute("""
            SELECT ID_UTIL, UTILIZATOR
            FROM CONTAFIN_ORACLE.UTILIZATORI
            WHERE UPPER(EMAIL) = UPPER(:email)
        """, {"email": request.email})

        user_row = cursor.fetchone()
        if not user_row:
            raise HTTPException(status_code=404, detail="Email not found")

        user_id, username = user_row

        # 2. Verify password via stored procedure
        cursor.execute("""
            SELECT pack_drepturi.verificautilizator(:username, :password)
            FROM DUAL
        """, {"username": username, "password": request.password})

        result = cursor.fetchone()[0]
        if result == -1:
            raise HTTPException(status_code=401, detail="Invalid password")

        # 3. Get user companies
        companies = get_user_companies(user_id, connection)

        # 4. Generate JWT tokens
        access_token = create_access_token(...)
        refresh_token = create_refresh_token(...)

        return TelegramEmailLoginResponse(
            success=True,
            access_token=access_token,
            refresh_token=refresh_token,
            user_id=user_id,
            username=username,
            companies=companies,
            message="Authentication successful"
        )
```

**Securitate:**
- Rate limiting: 5 requests / 5 minutes per telegram_user_id
- Password validation prin Oracle stored procedure (nu stocăm parole)
- HTTPS required în producție
- Logging pentru failed attempts

---

### 4. Bot Handlers NOI: `/login` + ConversationHandler

**Fișier NOU**: `reports-app/telegram-bot/app/bot/email_handlers.py`

#### Command: `/login`

```python
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import ContextTypes, ConversationHandler, CommandHandler, MessageHandler, filters

# Conversation states
AWAITING_EMAIL, AWAITING_CODE, AWAITING_PASSWORD = range(3)

async def login_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """
    Handler pentru /login command
    Inițiază conversation pentru email auth
    """
    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"
            "Folosește /unlink pentru a te deautentifica."
        )
        return ConversationHandler.END

    # Afișează metode de autentificare
    keyboard = [
        [InlineKeyboardButton("🔐 Login cu Email", callback_data="email_login")],
        [InlineKeyboardButton("🌐 Login din Web App", callback_data="web_login")],
        [InlineKeyboardButton("❌ Anulează", callback_data="cancel")]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)

    await update.message.reply_text(
        "🔑 Alege metoda de autentificare:\n\n"
        "📧 **Email + Parolă**: Primești cod pe email, apoi introduci parola\n"
        "🌐 **Web App**: Generează cod din aplicația web",
        reply_markup=reply_markup
    )

    return AWAITING_EMAIL

async def email_login_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Callback pentru butonul 'Login cu Email'"""
    query = update.callback_query
    await query.answer()

    await query.edit_message_text(
        "📧 **Autentificare prin Email**\n\n"
        "Te rugăm să introduci adresa ta de email Oracle:\n"
        "(Exemplu: nume.prenume@companie.ro)"
    )

    return AWAITING_EMAIL

async def receive_email(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """
    Handler pentru primirea email-ului
    """
    email = update.message.text.strip()
    user_id = update.effective_user.id

    # Validare format email
    if not is_valid_email(email):
        await update.message.reply_text(
            "❌ Email invalid. Te rugăm să introduci o adresă de email validă."
        )
        return AWAITING_EMAIL

    # Verifică email în Oracle + trimite cod
    try:
        # 1. Verifică email în Oracle UTILIZATORI
        username = await verify_email_in_oracle(email)
        if not username:
            await update.message.reply_text(
                "❌ Email-ul nu este înregistrat în sistem.\n"
                "Contactează administratorul pentru a-ți adăuga email-ul."
            )
            return ConversationHandler.END

        # 2. Generează cod 6-digit
        code = generate_6digit_code()

        # 3. Salvează în email_auth_codes
        await save_email_auth_code(
            code=code,
            email=email,
            username=username,
            telegram_user_id=user_id
        )

        # 4. Trimite email
        email_sent = await email_service.send_auth_code(email, code, username)

        if not email_sent:
            await update.message.reply_text(
                "❌ Eroare la trimiterea email-ului. Te rugăm să încerci din nou."
            )
            return ConversationHandler.END

        # 5. Salvează email în context
        context.user_data['pending_email'] = email
        context.user_data['pending_username'] = username

        await update.message.reply_text(
            f"✉️ **Cod trimis pe {email}**\n\n"
            "Verifică inbox-ul (și spam) și introdu codul de 6 cifre.\n"
            "⏱ Codul expiră în **5 minute**.\n\n"
            "Scrie /cancel pentru a anula."
        )

        return AWAITING_CODE

    except Exception as e:
        logger.error(f"Email login error: {e}")
        await update.message.reply_text(
            "❌ Eroare internă. Te rugăm să încerci din nou mai târziu."
        )
        return ConversationHandler.END

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

    # Validare format cod (6 digits)
    if not code.isdigit() or len(code) != 6:
        await update.message.reply_text(
            "❌ Cod invalid. Introdu cele 6 cifre din email."
        )
        return AWAITING_CODE

    # Verifică cod în DB
    try:
        code_data = await get_email_auth_code(code)

        if not code_data:
            await update.message.reply_text(
                "❌ Cod invalid sau expirat. Te rugăm să reîncepi cu /login"
            )
            return ConversationHandler.END

        # Verificări
        if code_data['used']:
            await update.message.reply_text(
                "❌ Cod deja folosit. Te rugăm să reîncepi cu /login"
            )
            return ConversationHandler.END

        if code_data['telegram_user_id'] != user_id:
            await update.message.reply_text(
                "❌ Codul nu îți aparține."
            )
            return ConversationHandler.END

        if datetime.now() > code_data['expires_at']:
            await update.message.reply_text(
                "❌ Codul a expirat. Te rugăm să reîncepi cu /login"
            )
            return ConversationHandler.END

        # Marchează cod ca folosit
        await mark_email_code_used(code)

        # Salvează username în context
        context.user_data['verified_username'] = code_data['oracle_username']
        context.user_data['verified_email'] = code_data['email']

        await update.message.reply_text(
            "✅ **Cod validat cu succes!**\n\n"
            "🔐 Acum introdu parola ta Oracle:\n"
            "(Parola va fi ștearsă automat după verificare)"
        )

        return AWAITING_PASSWORD

    except Exception as e:
        logger.error(f"Code validation error: {e}")
        await update.message.reply_text(
            "❌ Eroare la validarea codului. Te rugăm să încerci din nou."
        )
        return ConversationHandler.END

async def receive_password(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """
    Handler pentru primirea parolei
    """
    password = update.message.text.strip()
    user_id = update.effective_user.id

    # Șterge imediat mesajul cu parola
    try:
        await update.message.delete()
    except:
        pass

    username = context.user_data.get('verified_username')
    email = context.user_data.get('verified_email')

    if not username or not email:
        await update.effective_chat.send_message(
            "❌ Sesiune expirată. Te rugăm să reîncepi cu /login"
        )
        return ConversationHandler.END

    # Trimite loading message
    loading_msg = await update.effective_chat.send_message(
        "⏳ Verificare credențiale..."
    )

    try:
        # Call backend endpoint
        response = await backend_client.login_with_email(
            email=email,
            password=password,
            telegram_user_id=user_id
        )

        if not response['success']:
            await loading_msg.edit_text(
                "❌ Parolă incorectă. Te rugăm să reîncepi cu /login"
            )
            return ConversationHandler.END

        # Salvează user în telegram_users
        await save_telegram_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,
            oracle_username=response['username'],
            jwt_token=response['access_token'],
            jwt_refresh_token=response['refresh_token']
        )

        # Success message
        companies_list = "\n".join([f"• {c['name']}" for c in response['companies'][:5]])

        await loading_msg.edit_text(
            f"✅ **Autentificat cu succes!**\n\n"
            f"👤 Utilizator: **{response['username']}**\n"
            f"🏢 Companii disponibile: {len(response['companies'])}\n\n"
            f"{companies_list}\n\n"
            f"Folosește /help pentru comenzi disponibile."
        )

        # Clear context
        context.user_data.clear()

        return ConversationHandler.END

    except Exception as e:
        logger.error(f"Password verification error: {e}")
        await loading_msg.edit_text(
            "❌ Eroare la autentificare. Te rugăm să încerci din nou cu /login"
        )
        return ConversationHandler.END

async def cancel_login(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Cancel conversation"""
    context.user_data.clear()
    await update.message.reply_text("❌ Autentificare anulată.")
    return ConversationHandler.END

# ConversationHandler setup
email_login_handler = ConversationHandler(
    entry_points=[
        CommandHandler('login', login_command),
        CallbackQueryHandler(email_login_callback, pattern='^email_login$')
    ],
    states={
        AWAITING_EMAIL: [MessageHandler(filters.TEXT & ~filters.COMMAND, receive_email)],
        AWAITING_CODE: [MessageHandler(filters.TEXT & ~filters.COMMAND, receive_code)],
        AWAITING_PASSWORD: [MessageHandler(filters.TEXT & ~filters.COMMAND, receive_password)],
    },
    fallbacks=[
        CommandHandler('cancel', cancel_login),
        CallbackQueryHandler(cancel_login, pattern='^cancel$')
    ],
    conversation_timeout=300  # 5 minute timeout
)
```

**Handler Registration** (în `app/bot/handlers.py`):
```python
from app.bot.email_handlers import email_login_handler

def setup_handlers(application):
    # ... existing handlers ...

    # Email login handler
    application.add_handler(email_login_handler)
```

---

### 5. Backend API Client Method

**Locație**: `reports-app/telegram-bot/app/api/client.py`

```python
class BackendAPIClient:
    # ... existing methods ...

    async def login_with_email(
        self,
        email: str,
        password: str,
        telegram_user_id: int
    ) -> dict:
        """
        Login via email + password
        """
        try:
            response = await self.client.post(
                f"{self.base_url}/api/telegram/auth/login-with-email",
                json={
                    "email": email,
                    "password": password,
                    "telegram_user_id": telegram_user_id
                }
            )
            response.raise_for_status()
            return response.json()
        except httpx.HTTPError as e:
            logger.error(f"Email login failed: {e}")
            raise
```

---

## 🔧 Environment Variables

### Backend `.env` (nu necesită modificări - doar pentru referință)
```bash
# Existente (nu modificăm)
ORACLE_USER=CONTAFIN_ORACLE
ORACLE_PASSWORD=your_password
ORACLE_HOST=localhost
ORACLE_PORT=1526
ORACLE_SID=ROA
JWT_SECRET_KEY=your_secret_key
JWT_ALGORITHM=HS256
JWT_EXPIRE_MINUTES=30
```

### Telegram Bot `.env` (ADAUGĂ ACESTEA)
```bash
# Existing
TELEGRAM_BOT_TOKEN=your_bot_token
BACKEND_URL=http://localhost:8000
DATABASE_PATH=data/telegram_bot.db

# NEW: SMTP Configuration
SMTP_HOST=mail.romfast.ro
SMTP_PORT=587
SMTP_USER=ups@romfast.ro
SMTP_PASSWORD=#Ups2020#
SMTP_FROM_EMAIL=ups@romfast.ro
SMTP_FROM_NAME=ROA2WEB
SMTP_USE_TLS=true

# NEW: Email Auth Settings
EMAIL_CODE_EXPIRY_MINUTES=5
EMAIL_CODE_LENGTH=6
MAX_EMAIL_ATTEMPTS_PER_HOUR=3
```

---

## 🔒 Securitate & Validări

### 1. Email Validation
```python
import re

def is_valid_email(email: str) -> bool:
    """Validare format email"""
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

async def verify_email_in_oracle(email: str) -> Optional[str]:
    """
    Verifică dacă email există în Oracle UTILIZATORI
    Returns: username dacă există, None altfel
    """
    async with oracle_pool.get_connection() as connection:
        cursor = connection.cursor()
        cursor.execute("""
            SELECT UTILIZATOR
            FROM CONTAFIN_ORACLE.UTILIZATORI
            WHERE UPPER(EMAIL) = UPPER(:email)
            AND ACTIV = 1
        """, {"email": email})

        row = cursor.fetchone()
        return row[0] if row else None
```

### 2. Code Generation & Storage
```python
import random
import string
from datetime import datetime, timedelta

def generate_6digit_code() -> str:
    """Generează cod random 6-digit"""
    return ''.join(random.choices(string.digits, k=6))

async def save_email_auth_code(
    code: str,
    email: str,
    username: str,
    telegram_user_id: int
) -> bool:
    """Salvează cod în DB cu expiry 5 minute"""
    expires_at = datetime.now() + timedelta(minutes=5)

    async with get_db_connection() as db:
        await db.execute("""
            INSERT INTO email_auth_codes
            (code, email, oracle_username, telegram_user_id, expires_at)
            VALUES (?, ?, ?, ?, ?)
        """, (code, email, username, telegram_user_id, expires_at))
        await db.commit()

    return True
```

### 3. Rate Limiting
```python
from collections import defaultdict
from datetime import datetime, timedelta

# In-memory rate limiter (sau Redis în producție)
email_attempts = defaultdict(list)

async def check_rate_limit(identifier: str, max_attempts: int = 3, window_minutes: int = 60) -> bool:
    """
    Rate limiting pentru email requests
    identifier poate fi: email sau telegram_user_id
    """
    now = datetime.now()
    cutoff = now - timedelta(minutes=window_minutes)

    # Curăță attempts vechi
    email_attempts[identifier] = [
        attempt for attempt in email_attempts[identifier]
        if attempt > cutoff
    ]

    # Verifică limita
    if len(email_attempts[identifier]) >= max_attempts:
        return False  # Rate limit exceeded

    # Adaugă attempt nou
    email_attempts[identifier].append(now)
    return True  # OK to proceed
```

### 4. Password Security
```python
async def receive_password(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handler cu securitate mărite pentru parolă"""
    password = update.message.text.strip()

    # 1. Șterge IMEDIAT mesajul cu parola
    try:
        await update.message.delete()
    except Exception as e:
        logger.warning(f"Could not delete password message: {e}")

    # 2. NU loga parola niciodată
    logger.info(f"Password received for user {update.effective_user.id}")

    # 3. Verifică parola prin backend (Oracle)
    # ... (vezi cod de mai sus)

    # 4. Șterge parola din memorie
    del password
```

### 5. Auto-Cleanup Job
```python
async def cleanup_expired_codes():
    """Job periodic pentru curățarea codurilor expirate"""
    while True:
        try:
            async with get_db_connection() as db:
                # Șterge email codes expirate
                await db.execute("""
                    DELETE FROM email_auth_codes
                    WHERE expires_at < ?
                    OR (used = 1 AND used_at < ?)
                """, (
                    datetime.now(),
                    datetime.now() - timedelta(days=1)  # Cleanup used codes după 1 zi
                ))
                await db.commit()

                deleted = db.total_changes
                logger.info(f"Cleaned up {deleted} expired email auth codes")

        except Exception as e:
            logger.error(f"Cleanup job error: {e}")

        # Run every hour
        await asyncio.sleep(3600)

# Start cleanup job în main.py
asyncio.create_task(cleanup_expired_codes())
```

---

## 📝 Fișiere Modificate/Create

### **CREATE** (6 fișiere noi):

1. **`reports-app/telegram-bot/app/utils/email_service.py`**
   - SMTP client pentru trimitere email-uri
   - Funcție: `send_auth_code(email, code, username)`
   - Error handling + retry logic

2. **`reports-app/telegram-bot/app/auth/email_auth.py`**
   - Logică autentificare email
   - Funcții: `verify_email_in_oracle()`, `generate_6digit_code()`, `check_rate_limit()`

3. **`reports-app/telegram-bot/app/bot/email_handlers.py`**
   - ConversationHandler pentru `/login`
   - States: AWAITING_EMAIL → AWAITING_CODE → AWAITING_PASSWORD
   - Handlers: `receive_email()`, `receive_code()`, `receive_password()`

4. **`reports-app/backend/app/schemas/telegram_email_auth.py`**
   - Pydantic schemas pentru email auth
   - `TelegramEmailLoginRequest`, `TelegramEmailLoginResponse`

5. **`reports-app/telegram-bot/tests/test_email_auth.py`**
   - Unit tests pentru email auth flow
   - Mock SMTP, Oracle, backend API

6. **`TELEGRAM_EMAIL_AUTH_PLAN.md`**
   - Acest document (plan detaliat)

### **MODIFY** (6 fișiere existente):

1. **`reports-app/telegram-bot/app/db/database.py`**
   - **Adaugă**: Schema tabela `email_auth_codes`
   - **Linie**: ~40-60 (în funcția `init_database()`)

2. **`reports-app/telegram-bot/app/db/operations.py`**
   - **Adaugă**: CRUD operations pentru `email_auth_codes`
   - Funcții noi: `create_email_auth_code()`, `get_email_auth_code()`, `mark_email_code_used()`, etc.
   - **Linii**: ~200-300 (la final de fișier)

3. **`reports-app/telegram-bot/app/bot/handlers.py`**
   - **Adaugă**: Import și register `email_login_handler`
   - **Linie**: ~10 (import), ~150 (register în `setup_handlers()`)
   - **Modificare**: Update `/start` message pentru a menționa `/login`

4. **`reports-app/backend/app/routers/telegram.py`**
   - **Adaugă**: Endpoint `POST /auth/login-with-email`
   - **Linii**: ~200-300 (la final de fișier)
   - **Import**: Adaugă schema `TelegramEmailLoginRequest/Response`

5. **`reports-app/telegram-bot/app/api/client.py`**
   - **Adaugă**: Method `login_with_email(email, password, telegram_user_id)`
   - **Linii**: ~150-180 (în clasa `BackendAPIClient`)

6. **`reports-app/telegram-bot/.env`**
   - **Adaugă**: SMTP configuration variables (vezi secțiunea Environment Variables)

### **NO TOUCH** (rămân 100% neschimbate):

- ✅ Fluxul actual de linking (web app → cod → /start)
- ✅ Tabele existente: `telegram_users`, `telegram_auth_codes`, `telegram_sessions`
- ✅ Endpoint-uri existente: `/generate-code`, `/verify-user`, `/refresh-token`
- ✅ Handler-e existente: `/start [code]`, `/companies`, `/dashboard`, `/facturi`, etc.
- ✅ Toate comenzile Telegram existente (funcționalitate păstrată 100%)

---

## 🧪 Testing Strategy

### 1. Unit Tests

**Fișier**: `reports-app/telegram-bot/tests/test_email_auth.py`

```python
import pytest
from unittest.mock import AsyncMock, patch
from app.auth.email_auth import verify_email_in_oracle, generate_6digit_code, check_rate_limit
from app.utils.email_service import EmailService

@pytest.mark.asyncio
async def test_generate_6digit_code():
    """Test generare cod 6-digit"""
    code = generate_6digit_code()
    assert len(code) == 6
    assert code.isdigit()

@pytest.mark.asyncio
async def test_verify_email_in_oracle_success():
    """Test verificare email valid în Oracle"""
    with patch('app.auth.email_auth.oracle_pool') as mock_pool:
        # Mock Oracle response
        mock_cursor = AsyncMock()
        mock_cursor.fetchone.return_value = ("test_user",)

        username = await verify_email_in_oracle("test@example.com")
        assert username == "test_user"

@pytest.mark.asyncio
async def test_verify_email_not_found():
    """Test email inexistent în Oracle"""
    with patch('app.auth.email_auth.oracle_pool') as mock_pool:
        mock_cursor = AsyncMock()
        mock_cursor.fetchone.return_value = None

        username = await verify_email_in_oracle("notfound@example.com")
        assert username is None

@pytest.mark.asyncio
async def test_rate_limiting():
    """Test rate limiting pentru email requests"""
    identifier = "test_user_123"

    # First 3 attempts should pass
    for i in range(3):
        result = await check_rate_limit(identifier, max_attempts=3, window_minutes=60)
        assert result is True

    # 4th attempt should fail
    result = await check_rate_limit(identifier, max_attempts=3, window_minutes=60)
    assert result is False

@pytest.mark.asyncio
async def test_email_service_send_code():
    """Test trimitere email cu cod"""
    email_service = EmailService()

    with patch('app.utils.email_service.smtplib.SMTP') as mock_smtp:
        result = await email_service.send_auth_code(
            to_email="test@example.com",
            code="123456",
            username="test_user"
        )

        assert result is True
        assert mock_smtp.called
```

### 2. Integration Tests

```python
@pytest.mark.asyncio
async def test_full_email_auth_flow():
    """Test complet: email → cod → parolă → JWT"""

    # 1. Request email code
    email = "mmarius28@gmail.com"
    telegram_user_id = 123456789

    with patch('app.auth.email_auth.verify_email_in_oracle') as mock_verify:
        mock_verify.return_value = "marius_user"

        # Generate code
        code = generate_6digit_code()
        await save_email_auth_code(code, email, "marius_user", telegram_user_id)

        # 2. Validate code
        code_data = await get_email_auth_code(code)
        assert code_data is not None
        assert code_data['email'] == email
        assert code_data['used'] is False

        # 3. Mock backend login
        with patch('app.api.client.BackendAPIClient.login_with_email') as mock_login:
            mock_login.return_value = {
                'success': True,
                'access_token': 'test_jwt_token',
                'refresh_token': 'test_refresh_token',
                'username': 'marius_user',
                'user_id': 42,
                'companies': []
            }

            # Verify password
            response = await backend_client.login_with_email(
                email=email,
                password="test_password",
                telegram_user_id=telegram_user_id
            )

            assert response['success'] is True
            assert 'access_token' in response
```

### 3. Manual Testing Checklist

**Fișier**: `reports-app/telegram-bot/tests/MANUAL_EMAIL_AUTH_TESTING.md`

```markdown
# Manual Testing Checklist - Email Authentication

## Prerequisites
- [ ] Backend running on port 8000
- [ ] Telegram bot running
- [ ] SMTP credentials configured in .env
- [ ] Test email: mmarius28@gmail.com exists in Oracle UTILIZATORI table

## Test Cases

### 1. Successful Authentication Flow
- [ ] Start bot: `/start`
- [ ] Type: `/login`
- [ ] Select "🔐 Login cu Email"
- [ ] Enter email: `mmarius28@gmail.com`
- [ ] Verify email received with 6-digit code
- [ ] Enter code from email
- [ ] Enter Oracle password
- [ ] Verify success message with companies list
- [ ] Test command: `/companies` (should work)

### 2. Invalid Email
- [ ] `/login`
- [ ] Enter email: `nonexistent@example.com`
- [ ] Verify error message: "Email-ul nu este înregistrat"

### 3. Expired Code
- [ ] `/login` → enter valid email
- [ ] Wait 6 minutes (code expiry = 5 min)
- [ ] Enter code
- [ ] Verify error: "Cod expirat"

### 4. Wrong Code
- [ ] `/login` → enter valid email
- [ ] Enter wrong code: `999999`
- [ ] Verify error: "Cod invalid"

### 5. Wrong Password
- [ ] `/login` → enter email → enter valid code
- [ ] Enter wrong password
- [ ] Verify error: "Parolă incorectă"

### 6. Rate Limiting
- [ ] `/login` → enter email (attempt 1)
- [ ] `/cancel`
- [ ] `/login` → enter email (attempt 2)
- [ ] `/cancel`
- [ ] `/login` → enter email (attempt 3)
- [ ] `/cancel`
- [ ] `/login` → enter email (attempt 4)
- [ ] Verify error: "Prea multe încercări. Încearcă în 60 minute"

### 7. Password Message Deletion
- [ ] `/login` → enter email → enter code
- [ ] Enter password
- [ ] Verify password message is deleted immediately
- [ ] Check chat history - password should not be visible

### 8. Cancel Flow
- [ ] `/login`
- [ ] `/cancel` (should cancel and clear state)

### 9. Already Authenticated
- [ ] Complete successful login
- [ ] Type `/login` again
- [ ] Verify message: "Ești deja autentificat"

### 10. Parallel Method (Web App Linking) Still Works
- [ ] Login to web app: http://localhost:3000
- [ ] Generate Telegram linking code
- [ ] Use `/start ABC123XY` in Telegram
- [ ] Verify linking works as before (OLD method)

### 11. Database Cleanup
- [ ] Create expired codes (manually set expires_at in past)
- [ ] Wait for hourly cleanup job
- [ ] Verify expired codes deleted from `email_auth_codes` table
```

---

## 📊 Estimare Efort & Timeline

### Breakdown Detaliat

| Componentă | Efort (ore) | Detalii |
|-----------|-------------|---------|
| **Backend** | | |
| → Endpoint `/login-with-email` | 1.5h | Logic + Oracle queries + JWT |
| → Schema Pydantic | 0.5h | Request/Response models |
| → Rate limiting | 0.5h | Middleware sau decorator |
| → Testing backend | 0.5h | Unit tests endpoint |
| **Telegram Bot** | | |
| → Email service (SMTP) | 1.5h | Client SMTP + templates + retry |
| → DB schema + operations | 1h | Tabela nouă + CRUD |
| → Email auth logic | 1h | Verificare email, cod generation |
| → ConversationHandler | 2h | States + handlers + callbacks |
| → API client method | 0.5h | Method nou în BackendAPIClient |
| → Testing bot | 1h | Unit + integration tests |
| **Integration** | | |
| → End-to-end testing | 1h | Flow complet manual |
| → Bug fixes | 1h | Edge cases |
| **Documentation** | | |
| → Update README | 0.5h | Secțiune nouă pentru email auth |
| → Update TELEGRAM_COMMANDS.md | 0.5h | Documentare `/login` |
| **TOTAL** | **~13h** | ~2 zile lucru (6-7h/zi) |

### Timeline Recomandat

**Ziua 1 (6-7h):**
1. Setup environment (SMTP config) - 0.5h
2. Backend: Endpoint + schema - 2h
3. Telegram Bot: Email service - 1.5h
4. Telegram Bot: DB schema + operations - 1h
5. Testing preliminar - 1h

**Ziua 2 (6-7h):**
1. Telegram Bot: ConversationHandler - 2h
2. Email auth logic - 1h
3. Integration - 1h
4. End-to-end testing - 1.5h
5. Documentation - 0.5h
6. Bug fixes - 1h

---

## ✅ Avantaje Plan

| Avantaj | Detalii |
|---------|---------|
| ✅ **Minimal Invaziv** | 0 modificări la logica existentă, doar adăugiri |
| ✅ **Ambele Metode** | Users pot alege: email+parolă SAU web app linking |
| ✅ **Backward Compatible** | Utilizatori fără email folosesc metoda actuală |
| ✅ **2FA Real** | Email possession (cod) + parolă Oracle = 2 factori |
| ✅ **Simplu de Testat** | Un singur utilizator cu email (mmarius28@gmail.com) |
| ✅ **Extensibil** | Ușor de activat pentru alți useri când adaugi email-uri |
| ✅ **Securitate Mărite** | Rate limiting, code expiry, password verification în Oracle |
| ✅ **Auto-Cleanup** | Job existent curăță automat coduri expirate |
| ✅ **User-Friendly** | Conversation flow natural în Telegram |
| ✅ **Error Handling** | Mesaje clare pentru fiecare caz de eroare |

---

## 🚀 Ordine Implementare (Step-by-Step)

### **Step 1: Environment Setup** (15 min)

1. Adaugă SMTP credentials în `.env`:
```bash
cd reports-app/telegram-bot/
echo "SMTP_HOST=mail.romfast.ro" >> .env
echo "SMTP_PORT=587" >> .env
echo "SMTP_USER=ups@romfast.ro" >> .env
echo "SMTP_PASSWORD=#Ups2020#" >> .env
echo "SMTP_FROM_EMAIL=ups@romfast.ro" >> .env
echo "SMTP_FROM_NAME=ROA2WEB" >> .env
```

2. Install dependencies:
```bash
pip install aiosmtplib  # Async SMTP client
```

### **Step 2: Backend - Endpoint** (2h)

1. Create schema: `backend/app/schemas/telegram_email_auth.py`
2. Add endpoint în `backend/app/routers/telegram.py`
3. Test cu Postman/curl

### **Step 3: Telegram Bot - Infrastructure** (2.5h)

1. Create `app/utils/email_service.py` (SMTP client)
2. Update `app/db/database.py` (add `email_auth_codes` table)
3. Update `app/db/operations.py` (CRUD operations)
4. Test DB operations

### **Step 4: Telegram Bot - Auth Logic** (1h)

1. Create `app/auth/email_auth.py`
2. Implement: `verify_email_in_oracle()`, `generate_6digit_code()`, `check_rate_limit()`
3. Unit tests

### **Step 5: Telegram Bot - Handlers** (2h)

1. Create `app/bot/email_handlers.py`
2. Implement ConversationHandler
3. Register în `app/bot/handlers.py`

### **Step 6: Backend API Client** (30 min)

1. Add `login_with_email()` method în `app/api/client.py`

### **Step 7: Integration Testing** (1h)

1. Start backend + bot
2. Test flow complet cu mmarius28@gmail.com
3. Fix bugs

### **Step 8: Comprehensive Testing** (1.5h)

1. Run all test cases from checklist
2. Test edge cases
3. Verify both methods work in parallel

### **Step 9: Documentation** (30 min)

1. Update README.md
2. Update TELEGRAM_COMMANDS.md
3. Create MANUAL_EMAIL_AUTH_TESTING.md

---

## 🐛 Troubleshooting Guide

### Issue: Email nu ajunge

**Cauze posibile:**
1. SMTP credentials incorecte
2. Port blocat (587)
3. Email în spam

**Debugging:**
```python
# Test SMTP connection
import smtplib

try:
    server = smtplib.SMTP('mail.romfast.ro', 587)
    server.starttls()
    server.login('ups@romfast.ro', '#Ups2020#')
    print("✅ SMTP connection OK")
    server.quit()
except Exception as e:
    print(f"❌ SMTP error: {e}")
```

### Issue: Cod invalid/expirat

**Debugging:**
```sql
-- Check code in DB
SELECT * FROM email_auth_codes WHERE code = '123456';

-- Check expiry
SELECT code, expires_at,
       datetime('now') as now,
       (julianday(expires_at) - julianday('now')) * 24 * 60 as minutes_remaining
FROM email_auth_codes
WHERE code = '123456';
```

### Issue: Parolă incorectă (dar știu că e corectă)

**Cauze posibile:**
1. Username găsit greșit din email
2. Oracle stored procedure error

**Debugging:**
```python
# Test Oracle auth direct
async with oracle_pool.get_connection() as connection:
    cursor = connection.cursor()

    # 1. Check email → username mapping
    cursor.execute("""
        SELECT UTILIZATOR, EMAIL
        FROM CONTAFIN_ORACLE.UTILIZATORI
        WHERE UPPER(EMAIL) = UPPER('mmarius28@gmail.com')
    """)
    print(cursor.fetchone())

    # 2. Test stored procedure
    cursor.execute("""
        SELECT pack_drepturi.verificautilizator('marius_user', 'parola_mea')
        FROM DUAL
    """)
    result = cursor.fetchone()[0]
    print(f"Auth result: {result}")  # -1 = fail, user_id = success
```

### Issue: Rate limiting prea restrictiv

**Quick fix:**
```python
# În email_auth.py, increase limits
MAX_EMAIL_ATTEMPTS = 5  # was 3
RATE_LIMIT_WINDOW_MINUTES = 30  # was 60
```

---

## 📚 Additional Documentation

### Email Template (HTML)

```html
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; }
        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; border-radius: 10px 10px 0 0; }
        .code-box { background-color: #f4f4f4; border: 2px solid #667eea; padding: 30px; margin: 20px 0; text-align: center; border-radius: 10px; }
        .code { font-size: 36px; font-weight: bold; letter-spacing: 10px; color: #667eea; font-family: 'Courier New', monospace; }
        .content { padding: 20px; background: white; }
        .warning { background-color: #fff3cd; border-left: 4px solid #ffc107; padding: 15px; margin: 20px 0; }
        .footer { text-align: center; color: #666; font-size: 12px; padding: 20px; border-top: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>🔐 ROA2WEB</h1>
            <p>Autentificare Telegram Bot</p>
        </div>

        <div class="content">
            <p>Salut <strong>{{username}}</strong>,</p>

            <p>Ai solicitat autentificarea în aplicația ROA2WEB Telegram Bot.</p>

            <div class="code-box">
                <p style="margin: 0; font-size: 14px; color: #666;">Codul tău de autentificare:</p>
                <p class="code">{{code}}</p>
            </div>

            <div class="warning">
                <strong>⏱️ Important:</strong> Acest cod expiră în <strong>5 minute</strong>.
            </div>

            <p>Introdu acest cod în conversația cu Telegram Bot, apoi vei fi solicitat să introduci parola.</p>

            <p style="margin-top: 30px; padding-top: 20px; border-top: 1px solid #ddd;">
                <strong>Nu ai solicitat acest cod?</strong><br>
                Dacă nu ai inițiat această autentificare, te rugăm să ignori acest email.
                Nimeni nu va avea acces la contul tău fără parola ta.
            </p>
        </div>

        <div class="footer">
            <p><strong>ROA2WEB</strong> - ERP Reports Application</p>
            <p>Acest email a fost trimis automat. Te rugăm să nu răspunzi.</p>
        </div>
    </div>
</body>
</html>
```

### Command Reference Update

Adaugă în `TELEGRAM_COMMANDS.md`:

```markdown
## /login

**Descriere**: Autentificare în Telegram Bot prin email + parolă (2FA)

**Sintaxă**: `/login`

**Flow**:
1. Selectezi metoda de autentificare (Email sau Web App)
2. Pentru Email:
   - Introduci adresa de email Oracle
   - Primești cod pe email (6 cifre)
   - Introduci codul din email
   - Introduci parola Oracle
   - Primești confirmare și acces la comenzi

**Exemple**:
```
/login
→ Selectează "🔐 Login cu Email"
→ Introdu: mmarius28@gmail.com
→ Verifică email și introdu cod: 123456
→ Introdu parola
→ ✅ Autentificat cu succes!
```

**Securitate**:
- Cod expiră în 5 minute
- Cod utilizabil o singură dată
- Parolă verificată în Oracle
- Mesajul cu parola este șters automat
- Rate limiting: max 3 încercări/oră

**Comandă alternativă**: Buton "🔐 Login cu Email" în meniu principal
```

---

## 🎓 Learning Points & Best Practices

### 1. De ce 6-digit code în loc de 8-char alphanumeric?

**Răspuns**:
- Mai ușor de tastat pe mobile
- Mai puțin prone la erori (0/O, 1/I confusion)
- Suficient de securizat pentru 5 minute expiry
- Standard în industrie (Google, GitHub, etc.)

### 2. De ce 5 minute expiry pentru cod?

**Răspuns**:
- Balans între security și UX
- Suficient timp pentru check email + type code
- Redus attack window pentru code guessing
- Similar cu alte aplicații 2FA

### 3. De ce șterge mesajul cu parola?

**Răspuns**:
- Securitate: parola nu rămâne în chat history
- Telegram API permite ștergerea mesajelor
- Best practice în bot-uri care cer credențiale
- Protecție dacă telefonul e compromis

### 4. De ce în-memory rate limiting și nu Redis?

**Răspuns**:
- **Simplitate**: Nu adaugă dependency nou
- **Suficient pentru scale mic-mediu**:
  - In-memory e OK pentru <1000 users concurrent
  - Planul curent: test cu 1 user, extend la 10-20 max
- **Upgrade path clar**: Dacă scală, migrăm la Redis
- **Code unchanged**: Interfața rămâne aceeași

### 5. De ce SQLite și nu PostgreSQL pentru bot DB?

**Răspuns**:
- **Consistency**: Sistemul actual folosește SQLite
- **Zero infrastructure**: No server setup needed
- **Sufficient performance**: Telegram bot = low traffic
- **Easy backup**: Single file (`telegram_bot.db`)
- **Deployment simplicity**: Works în Windows Service

---

## 🔗 Integrare cu Sistemul Existent

### Flow Diagram - Ambele Metode

```
                    ┌─────────────────────────────────┐
                    │   USER VREA SĂ SE AUTENTIFICE   │
                    │      ÎN TELEGRAM BOT            │
                    └─────────────┬───────────────────┘
                                  │
                                  ▼
                    ┌─────────────────────────────────┐
                    │     ALEGE METODA:               │
                    │  [Email + Parolă] sau [Web App] │
                    └─────────┬───────────┬───────────┘
                              │           │
                 ┌────────────┘           └────────────┐
                 │                                     │
                 ▼                                     ▼
    ┌────────────────────────┐         ┌──────────────────────────┐
    │   METODA NOUĂ          │         │   METODA EXISTENTĂ       │
    │   Email + Parolă       │         │   Web App Linking        │
    └────────────────────────┘         └──────────────────────────┘
                 │                                     │
                 ▼                                     ▼
    1. /login în Telegram          1. Login în web app (username+pass)
    2. Introdu email               2. Click "Link Telegram"
    3. Primești cod pe email       3. Backend generează cod 8-char
    4. Introdu cod în Telegram     4. Backend → POST /internal/save-code → Bot
    5. Introdu parolă              5. User: /start ABC123XY
    6. Bot verifică în Oracle      6. Bot auto-link (fără parolă din nou)
                 │                                     │
                 └──────────────┬──────────────────────┘
                                │
                                ▼
                ┌───────────────────────────────────┐
                │  USER AUTENTIFICAT ÎN BOT         │
                │  JWT tokens saved în telegram_users│
                └───────────────────────────────────┘
                                │
                                ▼
                ┌───────────────────────────────────┐
                │  COMENZI DISPONIBILE:              │
                │  /companies, /dashboard,           │
                │  /facturi, /trezorerie, etc.       │
                └───────────────────────────────────┘
```

### Database Schema - Complete View

```sql
-- EXISTING TABLE (no changes)
CREATE TABLE telegram_users (
    telegram_user_id INTEGER PRIMARY KEY,
    username TEXT,
    first_name TEXT,
    last_name TEXT,
    oracle_username TEXT,
    jwt_token TEXT,
    jwt_refresh_token TEXT,
    token_expires_at TIMESTAMP,
    linked_at TIMESTAMP,
    last_active_at TIMESTAMP,
    is_active BOOLEAN
);

-- EXISTING TABLE (no changes)
CREATE TABLE telegram_auth_codes (
    code TEXT PRIMARY KEY,              -- 8-char code from web app
    telegram_user_id INTEGER,
    oracle_username TEXT,
    created_at TIMESTAMP,
    expires_at TIMESTAMP,
    used BOOLEAN DEFAULT 0,
    used_at TIMESTAMP
);

-- NEW TABLE (for email auth)
CREATE TABLE email_auth_codes (
    code TEXT PRIMARY KEY,              -- 6-digit code sent via email
    email TEXT NOT NULL,
    oracle_username TEXT NOT NULL,
    telegram_user_id INTEGER NOT NULL,
    created_at TIMESTAMP,
    expires_at TIMESTAMP,
    used BOOLEAN DEFAULT 0,
    used_at TIMESTAMP,

    INDEX idx_email (email),
    INDEX idx_telegram_user_id (telegram_user_id)
);

-- EXISTING TABLE (no changes)
CREATE TABLE telegram_sessions (
    session_id TEXT PRIMARY KEY,
    telegram_user_id INTEGER,
    active_company_id INTEGER,
    active_company_name TEXT,
    conversation_state TEXT,
    created_at TIMESTAMP,
    updated_at TIMESTAMP,
    expires_at TIMESTAMP
);
```

**Observații:**
- `telegram_auth_codes` = pentru web app linking (EXISTING)
- `email_auth_codes` = pentru email auth (NEW)
- Ambele tabele coexistă, fiecare pentru flow-ul propriu
- `telegram_users` = comună pentru ambele metode (linked users)

---

## 🚦 Success Criteria

### Implementarea e considerată SUCCESS dacă:

- [x] ✅ User poate să facă `/login` în Telegram
- [x] ✅ User poate introduce email și primește cod pe email
- [x] ✅ User poate introduce cod din email (valid 5 min)
- [x] ✅ User poate introduce parola Oracle
- [x] ✅ Bot verifică credențialele în Oracle și generează JWT
- [x] ✅ User e autentificat și poate folosi comenzi (/companies, /dashboard, etc.)
- [x] ✅ Metoda veche (web app → /start cod) funcționează în continuare
- [x] ✅ Ambele metode pot fi folosite de același user (switch între ele)
- [x] ✅ Codurile expirate sunt auto-șterse
- [x] ✅ Mesajul cu parola e șters automat din chat
- [x] ✅ Rate limiting funcționează (max 3 emails/oră)
- [x] ✅ Error handling: mesaje clare pentru fiecare caz de eroare
- [x] ✅ Testare cu mmarius28@gmail.com funcționează end-to-end

---

## 📅 Next Steps După Implementare

### Immediate (după deploy)

1. **Testare cu user real (Marius)**
   - Verifică flow complet cu mmarius28@gmail.com
   - Test ambele metode de autentificare
   - Validează email delivery și formatting

2. **Monitoring**
   - Watch logs pentru erori SMTP
   - Monitor rate limiting triggers
   - Check database growth (`email_auth_codes` table)

### Short-term (1-2 săptămâni)

1. **Adaugă email pentru alți useri**
   - Identifică 5-10 useri pentru beta testing
   - Adaugă email-uri în Oracle `UTILIZATORI` table
   - Anunță disponibilitatea noii metode

2. **Collect feedback**
   - UX pentru conversation flow
   - Timing email delivery (sunt 5 min suficienți?)
   - Edge cases descoperite

### Long-term (1-3 luni)

1. **Analytics**
   - Câți useri folosesc fiecare metodă?
   - Success rate pentru fiecare flow
   - Common error patterns

2. **Optimizări**
   - Migrate rate limiting la Redis (dacă scală)
   - Adaugă email templates multiple (română + engleză)
   - Consider migration de la SQLite la PostgreSQL (dacă >1000 users)

3. **Feature extensions**
   - Email verification pentru schimbare parolă
   - Email notifications pentru events (reports ready, etc.)
   - Multi-language support

---

## 📞 Contact & Support

**Developer**: Claude Code (Anthropic)
**Project**: ROA2WEB - ERP Reports Application
**Date**: 2025-11-07

**Pentru întrebări despre acest plan:**
- Review cod în `reports-app/telegram-bot/` și `reports-app/backend/`
- Consultă `CLAUDE.md` pentru context general
- Check `TELEGRAM_COMMANDS.md` pentru comenzi existente

**Resurse utile:**
- python-telegram-bot docs: https://docs.python-telegram-bot.org/
- FastAPI docs: https://fastapi.tiangolo.com/
- aiosmtplib docs: https://aiosmtplib.readthedocs.io/

---

## 🎉 Conclusion

Acest plan implementează autentificare **email + parolă (2FA)** pentru Telegram Bot în mod **minimal invaziv**, păstrând întreaga funcționalitate existentă.

**Key highlights:**
- ✅ **0 breaking changes** - metoda veche funcționează în continuare
- ✅ **Simplu de implementat** - ~13h efort total
- ✅ **Securizat** - 2FA real cu rate limiting
- ✅ **Extensibil** - ușor de scalat pentru mai mulți useri
- ✅ **User-friendly** - conversation flow natural

**Ready to implement!** 🚀

---

*Document generat: 2025-11-07*
*Versiune: 1.0*
*Status: Planning Phase - Ready for Implementation*